@crypto512/jicon-mcp 2.2.1 → 2.3.19

package/dist/utils/buffer-tools.js

@@ -3,11 +3,15 @@
  *
  * Provides tools to retrieve chunks from buffered content,
  * list active buffers, clear buffers, search content, and edit content.
+ *
+ * All buffer operations use the session-scoped buffer from getSessionBuffer()
+ * which provides isolation between MCP sessions.
  */
 import { z } from "zod";
-import { contentBuffer } from "./content-buffer.js";
+import { getSessionBuffer } from "../session/context.js";
 import { formatSuccess, formatSuccessDirect, formatError, getMaxOutputSize } from "./response-formatter.js";
-import { executePipelineWithOutput, validatePipeline, BufferPipelineInputSchema, } from "./buffer-pipeline/index.js";
+import { getSchema, extractSamples } from "./schemas/index.js";
+import { executeTransform, BufferTransformInputSchema, } from "./sandbox/index.js";
 import { createJsonStructure, replaceInJsonArray, setByKeys, appendToJsonArray } from "./json-structure.js";
 import { parseXhtml, serializeXhtml, validateXhtmlAsync, buildPlantUmlMacro, detectRawPlantUml, detectPlantUmlInContent, 
 // Element ID-based operations
@@ -63,7 +67,7 @@ function formatGrepOutput(result, showLineNumbers) {
  * Type-safe buffer access: tools should only accept buffers of the type they understand.
  */
 function validateBufferType(bufferId, expectedTypes, toolName) {
-    const bufferInfo = contentBuffer.getInfo(bufferId);
+    const bufferInfo = getSessionBuffer().getInfo(bufferId);
     if (!bufferInfo) {
         return {
             error: true,
@@ -74,7 +78,7 @@ function validateBufferType(bufferId, expectedTypes, toolName) {
                 details: {
                     code: "BUFFER_NOT_FOUND",
                     bufferId,
-                    hint: "Use buffer_list() to see active buffers",
+                    hint: 'Use buffer_list() to see active buffers. Call help(topic="buffers") for buffer workflow guide.',
                 },
             }),
         };
@@ -82,11 +86,11 @@ function validateBufferType(bufferId, expectedTypes, toolName) {
     const actualType = bufferInfo.metadata?.contentType;
     if (!expectedTypes.includes(actualType ?? "")) {
         const typeHints = {
-            json: "Use buffer_pipeline for JSON data, or buffer_create(contentType='json') to create JSON buffers.",
+            json: "Use buffer_transform for JSON data, or buffer_create(contentType='json') to create JSON buffers.",
             xhtml: "Use buffer_create(contentType='xhtml') to create XHTML buffers, or confluence_get_page/confluence_edit to load Confluence content.",
         };
         const suggestedTools = {
-            json: "buffer_pipeline, buffer_get_items, buffer_set_items",
+            json: "buffer_transform, buffer_get_items, buffer_set_items",
             xhtml: "buffer_edit, buffer_get_structure, buffer_get_element, confluence_draft_create",
         };
         const hint = actualType ? typeHints[actualType] || "" : "";
@@ -104,6 +108,7 @@ function validateBufferType(bufferId, expectedTypes, toolName) {
                     actualType: actualType || "unknown",
                     hint: hint || `Create a ${expectedTypes[0]} buffer first.`,
                     suggestedTools: suggested ? `For ${actualType} buffers, use: ${suggested}` : undefined,
+                    tip: 'Call help(topic="buffers") for buffer types and workflow guide.',
                 },
             }),
         };
@@ -153,7 +158,7 @@ async function handleXhtmlEdit(args, bufferInfo) {
         const op = operations[opIndex];
         if (op.fromBufferId) {
             // Validate source buffer exists
-            const sourceInfo = contentBuffer.getInfo(op.fromBufferId);
+            const sourceInfo = getSessionBuffer().getInfo(op.fromBufferId);
             if (!sourceInfo) {
                 return formatError({
                     error: true,
@@ -162,7 +167,7 @@ async function handleXhtmlEdit(args, bufferInfo) {
                 });
             }
             // Get source buffer content
-            const sourceChunk = contentBuffer.getChunk(op.fromBufferId, 0, sourceInfo.bufferSizeBytes);
+            const sourceChunk = getSessionBuffer().getChunk(op.fromBufferId, 0, sourceInfo.bufferSizeBytes);
             if (!sourceChunk) {
                 return formatError({
                     error: true,
@@ -183,7 +188,7 @@ async function handleXhtmlEdit(args, bufferInfo) {
         }
     }
     // Get buffer content
-    const chunk = contentBuffer.getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+    const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
     if (!chunk) {
         return formatError({
             error: true,
@@ -366,7 +371,7 @@ async function handleXhtmlEdit(args, bufferInfo) {
     // Rebuild structure
     const newStructure = parseStructure(parseResult.document);
     // Update buffer
-    contentBuffer.update(args.bufferId, newContent, { contentType: "xhtml" }, newStructure.structure, newStructure.nextId);
+    getSessionBuffer().update(args.bufferId, newContent, { contentType: "xhtml" }, newStructure.structure, newStructure.nextId);
     return formatSuccessDirect({
         bufferId: args.bufferId,
         success: true,
@@ -385,7 +390,7 @@ async function handleXhtmlEdit(args, bufferInfo) {
 function handlePlainTextEdit(args) {
     // Handle append for plain/json buffers
     if (args.append && args.content) {
-        const result = contentBuffer.append(args.bufferId, args.content);
+        const result = getSessionBuffer().append(args.bufferId, args.content);
         if (!result) {
             return formatError({
                 error: true,
@@ -412,7 +417,7 @@ function handlePlainTextEdit(args) {
             },
         });
     }
-    const result = contentBuffer.edit(args.bufferId, args.oldString, args.newString, args.replaceAll ?? false);
+    const result = getSessionBuffer().edit(args.bufferId, args.oldString, args.newString, args.replaceAll ?? false);
     if (!result) {
         return formatError({
             error: true,
@@ -435,7 +440,7 @@ export function createBufferTools() {
         buffer_create: {
             description: `Create a new buffer with initial content. Returns bufferId and structure.
 
-Types: xhtml (Confluence storage, returns element IDs), json (data, use buffer_get_items or buffer_pipeline).
+Types: xhtml (Confluence storage, returns element IDs), json (data, use buffer_get_items or buffer_transform).
 JSON accepts string or native object/array (auto-stringified).
 Run help(topic="storage") for XHTML syntax.`,
             inputSchema: z.object({
@@ -511,7 +516,7 @@ Run help(topic="storage") for XHTML syntax.`,
                         nextId = structureResult.nextId;
                         // Serialize back (now with data-jicon-id attributes)
                         const contentWithIds = serializeXhtml(parseResult.document);
-                        bufferId = contentBuffer.storeWithStructure(contentWithIds, structure, nextId, mergedMetadata);
+                        bufferId = getSessionBuffer().storeWithStructure(contentWithIds, structure, nextId, mergedMetadata);
                     }
                     else if (args.contentType === "json") {
                         // Parse JSON and create structure with item IDs (for arrays)
@@ -529,14 +534,14 @@ Run help(topic="storage") for XHTML syntax.`,
                         // Create JSON structure (handles arrays with IDs, objects with keys)
                         const { content: contentWithIds, structure: jsonStruct } = createJsonStructure(data);
                         jsonStructure = jsonStruct;
-                        bufferId = contentBuffer.storeJsonWithStructure(contentWithIds, jsonStruct, mergedMetadata);
+                        bufferId = getSessionBuffer().storeJsonWithStructure(contentWithIds, jsonStruct, mergedMetadata);
                     }
                     else {
                         // TypeScript exhaustiveness check - should never reach here
                         const _exhaustiveCheck = args.contentType;
                         throw new Error(`Unsupported content type: ${_exhaustiveCheck}`);
                     }
-                    const info = contentBuffer.getInfo(bufferId);
+                    const info = getSessionBuffer().getInfo(bufferId);
                     // Build response based on content type
                     const isArray = jsonStructure?.rootType === "array";
                     const isObject = jsonStructure?.rootType === "object";
@@ -548,7 +553,7 @@ Run help(topic="storage") for XHTML syntax.`,
                         : undefined;
                     // Build hint for JSON buffers
                     const hint = args.contentType === "json" && isArray
-                        ? `Use buffer_pipeline(sourceBufferId='${bufferId}', pipeline={...}) to filter, transform, and output as XHTML/CSV/JSON.`
+                        ? `Use buffer_transform(inputs={data:'${bufferId}'}, code='...') to filter, transform, and output.`
                         : args.contentType === "json"
                             ? `Use buffer_get_items(bufferId='${bufferId}', keys=[...]) to access values, or buffer_grep to search.`
                             : undefined;
@@ -557,7 +562,6 @@ Run help(topic="storage") for XHTML syntax.`,
                         bufferSizeBytes: info?.bufferSizeBytes ?? contentStr.length,
                         contentType: args.contentType,
                         createdAt: info ? new Date(info.createdAt).toISOString() : new Date().toISOString(),
-                        expiresAt: info ? new Date(info.expiresAt).toISOString() : undefined,
                         metadata: mergedMetadata,
                         // XHTML structure
                         ...(structure && { structure, nextId }),
@@ -573,7 +577,7 @@ Run help(topic="storage") for XHTML syntax.`,
                         ...(hint && { hint }),
                         message: args.contentType === "xhtml"
                             ? "Buffer created with element IDs. Use buffer_edit with after/before/replace to modify."
-                            : "JSON buffer created. Use buffer_get_items for access or buffer_pipeline for transformation.",
+                            : "JSON buffer created. Use buffer_get_items for access or buffer_transform for transformation.",
                     });
                 }
                 catch (error) {
@@ -614,7 +618,7 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                     if (typeError)
                         return typeError.result;
                     // Get full buffer content
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
                     if (!bufferInfo) {
                         return formatError({
                             error: true,
@@ -622,7 +626,7 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                             statusCode: 404,
                         });
                     }
-                    const chunk = contentBuffer.getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+                    const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
                     if (!chunk) {
                         return formatError({
                             error: true,
@@ -653,7 +657,7 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                         if (parsed.length > 0 && typeof parsed[0] === "object" && parsed[0] !== null) {
                             itemSchema = Object.keys(parsed[0]);
                         }
-                        return formatSuccess({
+                        return formatSuccessDirect({
                             bufferId: args.bufferId,
                             type: "array",
                             items,
@@ -663,7 +667,7 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                             hasMore,
                             nextStart: hasMore ? start + count : undefined,
                             itemSchema: itemSchema ? itemSchema.slice(0, 20) : undefined,
-                        });
+                        }, { truncateHint: "Too many items. Use smaller count parameter." });
                     }
                     // Handle objects (new behavior)
                     if (typeof parsed === "object" && parsed !== null) {
@@ -683,7 +687,7 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                                     missingKeys.push(key);
                                 }
                             }
-                            return formatSuccess({
+                            return formatSuccessDirect({
                                 bufferId: args.bufferId,
                                 type: "object",
                                 data: result,
@@ -691,20 +695,20 @@ Returns: For arrays: items, totalItems, hasMore. For objects: data, keys.`,
                                 foundKeys,
                                 ...(missingKeys.length > 0 && { missingKeys }),
                                 availableKeys: allKeys,
-                            });
+                            }, { truncateHint: "Response truncated. Request fewer keys." });
                         }
                         else {
                             // Return all keys
-                            return formatSuccess({
+                            return formatSuccessDirect({
                                 bufferId: args.bufferId,
                                 type: "object",
                                 data,
                                 keys: allKeys,
-                            });
+                            }, { truncateHint: "Response truncated. Use keys parameter to request specific fields." });
                         }
                     }
                     // Handle primitives (edge case)
-                    return formatSuccess({
+                    return formatSuccessDirect({
                         bufferId: args.bufferId,
                         type: "primitive",
                         data: parsed,
@@ -749,7 +753,7 @@ Returns: Updated buffer info with changes summary.`,
                     if (typeError)
                         return typeError.result;
                     // Get buffer info
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
                     if (!bufferInfo) {
                         return formatError({
                             error: true,
@@ -776,7 +780,7 @@ Returns: Updated buffer info with changes summary.`,
                             },
                         });
                     }
-                    const chunk = contentBuffer.getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+                    const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
                     if (!chunk) {
                         return formatError({
                             error: true,
@@ -801,7 +805,7 @@ Returns: Updated buffer info with changes summary.`,
                                 });
                             }
                             // Update buffer with new content
-                            const updated = contentBuffer.updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
+                            const updated = getSessionBuffer().updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
                             if (!updated) {
                                 return formatError({
                                     error: true,
@@ -846,7 +850,7 @@ Returns: Updated buffer info with changes summary.`,
                             });
                         }
                         // Update buffer with new content
-                        const updated = contentBuffer.updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
+                        const updated = getSessionBuffer().updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
                         if (!updated) {
                             return formatError({
                                 error: true,
@@ -890,7 +894,7 @@ Returns: Updated buffer info with changes summary.`,
                             });
                         }
                         // Update buffer with new content
-                        const updated = contentBuffer.updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
+                        const updated = getSessionBuffer().updateJsonStructure(args.bufferId, result.content, result.structure, { contentType: "json" });
                         if (!updated) {
                             return formatError({
                                 error: true,
@@ -920,18 +924,17 @@ Returns: Updated buffer info with changes summary.`,
             },
         },
         buffer_list: {
-            description: `List all active buffers with metadata. Buffers expire after 1 hour (24h if modified).
-Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost buffer IDs.`,
+            description: `List all active buffers with metadata. Buffers are cleaned up when session ends.
+Max buffers per session configurable via JICON_MAX_BUFFERS (default: 10); oldest unmodified evicted first when full.`,
             inputSchema: z.object({}),
             handler: async () => {
                 try {
-                    const buffers = contentBuffer.list();
+                    const buffers = getSessionBuffer().list();
                     return formatSuccess({
                         count: buffers.length,
                         buffers: buffers.map((b) => ({
                             ...b,
                             createdAt: new Date(b.createdAt).toISOString(),
-                            expiresAt: new Date(b.expiresAt).toISOString(),
                         })),
                     });
                 }
@@ -940,6 +943,113 @@ Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost b
                 }
             },
         },
+        buffer_get_schema: {
+            description: `Get the schema for a JSON buffer. Returns field names, types, and sample values.
+
+Use this to understand buffer structure before writing buffer_transform code.
+The schema shows all available fields with their types and example values from the actual data.
+
+Returns:
+- schemaType: Named schema type (e.g., "jira_issue", "tempo_worklog")
+- fields: Object with field definitions (type, required, description, sample)
+- itemCount: Number of items (for arrays)
+
+Example: buffer_get_schema(bufferId="buf_xxx")`,
+            inputSchema: z.object({
+                bufferId: z.string().describe("Buffer ID to get schema for"),
+            }),
+            handler: async (args) => {
+                try {
+                    // Type-safe buffer access: buffer_get_schema requires JSON buffer
+                    const typeError = validateBufferType(args.bufferId, ["json"], "buffer_get_schema");
+                    if (typeError)
+                        return typeError.result;
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
+                    if (!bufferInfo) {
+                        return formatError({
+                            error: true,
+                            message: `Buffer not found or expired: ${args.bufferId}`,
+                            statusCode: 404,
+                        });
+                    }
+                    const schemaType = bufferInfo.schemaType;
+                    // If buffer has a schemaType, get the schema definition and samples
+                    if (schemaType) {
+                        const schemaDef = getSchema(schemaType);
+                        if (schemaDef) {
+                            // Get actual data to extract samples
+                            const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+                            if (chunk) {
+                                try {
+                                    const data = JSON.parse(chunk.chunk);
+                                    const schemaWithSamples = extractSamples(schemaType, data);
+                                    if (schemaWithSamples) {
+                                        return formatSuccessDirect({
+                                            bufferId: args.bufferId,
+                                            schemaType,
+                                            description: schemaDef.description,
+                                            itemCount: bufferInfo.jsonStructure?.itemCount,
+                                            legend: {
+                                                required: "Always present with a non-null value",
+                                                optional: "May be null when not set — use `== null` to check",
+                                                searchable: "Can be used in JQL/CQL queries",
+                                                writable: "Can be set via update API",
+                                                jqlName: "JQL clause name when different from field name (e.g., type → issuetype)",
+                                            },
+                                            fields: schemaWithSamples.fields,
+                                        }, { truncateHint: "Schema truncated." });
+                                    }
+                                }
+                                catch {
+                                    // Fall through to return schema without samples
+                                }
+                            }
+                            // Return schema without samples if we couldn't extract them
+                            return formatSuccessDirect({
+                                bufferId: args.bufferId,
+                                schemaType,
+                                description: schemaDef.description,
+                                itemCount: bufferInfo.jsonStructure?.itemCount,
+                                legend: {
+                                    required: "Always present with a non-null value",
+                                    optional: "May be null when not set — use `== null` to check",
+                                    searchable: "Can be used in JQL/CQL queries",
+                                    writable: "Can be set via update API",
+                                    jqlName: "JQL clause name when different from field name (e.g., type → issuetype)",
+                                },
+                                fields: schemaDef.fields,
+                            }, { truncateHint: "Schema truncated." });
+                        }
+                    }
+                    // No schemaType - return structure info from buffer
+                    const jsonStructure = bufferInfo.jsonStructure;
+                    if (!jsonStructure) {
+                        return formatError({
+                            error: true,
+                            message: "Buffer does not have JSON structure",
+                            statusCode: 400,
+                            details: {
+                                hint: "This buffer may not be a JSON buffer or was created without structure tracking",
+                            },
+                        });
+                    }
+                    // For untyped buffers, return what we know
+                    return formatSuccessDirect({
+                        bufferId: args.bufferId,
+                        schemaType: null,
+                        note: "Buffer has no schema type. Use buffer_get_items to inspect data structure.",
+                        structure: {
+                            type: jsonStructure.rootType,
+                            itemCount: jsonStructure.itemCount,
+                            keys: jsonStructure.keys,
+                        },
+                    });
+                }
+                catch (error) {
+                    return formatError(error instanceof Error ? error : new Error(String(error)));
+                }
+            },
+        },
         buffer_clear: {
             description: `Clear a specific buffer or all buffers. Omit bufferId to clear all.`,
             inputSchema: z.object({
@@ -951,7 +1061,7 @@ Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost b
             handler: async (args) => {
                 try {
                     if (args.bufferId) {
-                        const deleted = contentBuffer.clear(args.bufferId);
+                        const deleted = getSessionBuffer().clear(args.bufferId);
                         if (!deleted) {
                             return formatError({
                                 error: true,
@@ -964,8 +1074,8 @@ Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost b
                             cleared: 1,
                         });
                     }
-                    const count = contentBuffer.size();
-                    contentBuffer.clear();
+                    const count = getSessionBuffer().size();
+                    getSessionBuffer().clear();
                     return formatSuccess({
                         message: "All buffers cleared",
                         cleared: count,
@@ -1027,7 +1137,7 @@ Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost b
                     // Handle -C overriding -A/-B
                     const before = args["-C"] ?? args["-B"] ?? 0;
                     const after = args["-C"] ?? args["-A"] ?? 0;
-                    const result = contentBuffer.grep(args.bufferId, args.pattern, {
+                    const result = getSessionBuffer().grep(args.bufferId, args.pattern, {
                         caseInsensitive: args["-i"] ?? false,
                         before,
                         after,
@@ -1067,7 +1177,7 @@ Max 20 buffers; oldest unmodified evicted first when full. Use to recover lost b
                         if (fullText.length > maxSize) {
                             const wrapperData = { content: fullText, type: "grep_result" };
                             const { content: jsonContent, structure } = createJsonStructure(wrapperData);
-                            const newBufferId = contentBuffer.storeJsonWithStructure(jsonContent, structure, {
+                            const newBufferId = getSessionBuffer().storeJsonWithStructure(jsonContent, structure, {
                                 contentType: "json",
                                 type: "grep_result",
                                 sourceBufferId: args.bufferId,
@@ -1144,7 +1254,7 @@ Run help(topic="buffers") for editing guide and examples.`,
             }),
             handler: async (args) => {
                 try {
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
                     if (!bufferInfo) {
                         return formatError({
                             error: true,
@@ -1181,12 +1291,12 @@ Each element has:
                     const typeError = validateBufferType(args.bufferId, ["xhtml"], "buffer_get_structure");
                     if (typeError)
                         return typeError.result;
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
-                    return formatSuccess({
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
+                    return formatSuccessDirect({
                         bufferId: args.bufferId,
                         structure: bufferInfo?.structure ?? [],
                         nextId: bufferInfo?.nextId ?? 1,
-                    });
+                    }, { truncateHint: "Structure truncated. Document has many elements." });
                 }
                 catch (error) {
                     return formatError(error instanceof Error ? error : new Error(String(error)));
@@ -1211,7 +1321,7 @@ Example: After a Confluence error at element 12, use this to see the content:
                     const typeError = validateBufferType(args.bufferId, ["xhtml"], "buffer_get_element");
                     if (typeError)
                         return typeError.result;
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
                     if (!bufferInfo) {
                         return formatError({
                             error: true,
@@ -1220,7 +1330,7 @@ Example: After a Confluence error at element 12, use this to see the content:
                         });
                     }
                     // Get full buffer content
-                    const chunk = contentBuffer.getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+                    const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
                     if (!chunk) {
                         return formatError({
                             error: true,
@@ -1263,13 +1373,13 @@ Example: After a Confluence error at element 12, use this to see the content:
                     if (elementType === "ac:structured-macro") {
                         elementType = element.getAttribute("ac:name") || "macro";
                     }
-                    return formatSuccess({
+                    return formatSuccessDirect({
                         bufferId: args.bufferId,
                         elementId: args.elementId,
                         elementType,
                         lineCount,
                         content,
-                    });
+                    }, { truncateHint: "Element content truncated. Element is very large." });
                 }
                 catch (error) {
                     return formatError(error instanceof Error ? error : new Error(String(error)));
@@ -1294,7 +1404,7 @@ Use before confluence_draft_create to catch errors early.`,
                     if (typeError)
                         return typeError.result;
                     // Get buffer content
-                    const bufferInfo = contentBuffer.getInfo(args.bufferId);
+                    const bufferInfo = getSessionBuffer().getInfo(args.bufferId);
                     if (!bufferInfo) {
                         return formatError({
                             error: true,
@@ -1302,7 +1412,7 @@ Use before confluence_draft_create to catch errors early.`,
                             statusCode: 404,
                         });
                     }
-                    const chunk = contentBuffer.getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
+                    const chunk = getSessionBuffer().getChunk(args.bufferId, 0, bufferInfo.bufferSizeBytes);
                     if (!chunk) {
                         return formatError({
                             error: true,
@@ -1352,147 +1462,172 @@ Use before confluence_draft_create to catch errors early.`,
             },
         },
         // =========================================================================
-        // Buffer Pipeline - Unified data transformation tool
+        // Buffer Transform - JavaScript sandbox for data transformation
         // =========================================================================
-        buffer_pipeline: {
-            description: `Transform JSON array with declarative pipeline (server-side, 98% token reduction).
+        buffer_transform: {
+            description: `Execute JavaScript code in a secure sandbox to transform buffer data.
+
+IMPORTANT: Call buffer_get_schema(bufferId) BEFORE writing transform code to discover field names, types, and which fields are optional (nullable).
 
-STAGES: select → filter → groupBy → sort → limit → format → output (required)
-OUTPUT: xhtml_table | xhtml_list | json | csv | markdown
-NOTE: xhtml/csv/md outputs are NOT iterable (buffer_get_items won't work). json IS iterable.
-RETURNS: bufferId, contentType, itemCount
+FLAT FIELD ACCESS:
+Buffer data uses FLAT fields (not nested). Use the field names from the schema.
+  CORRECT: i.status, i.assignee, i.priority
+  WRONG:   i.status.name, i.fields.status.name, i.assignee?.displayName
 
-Example: pipeline={filter:[{field:"status.name",operator:"ne",value:"Done"}],output:{type:"xhtml_table",table:{columns:[{field:"key"},{field:"summary"}]}}}
+NULL HANDLING: Optional fields (priority, assignee, time fields) are null when not set.
+  Filter unset: i.timeoriginalestimate == null (catches both null and undefined)
+  Filter zero:  i.timeoriginalestimate === 0  (only explicit zero)
 
-IMPORTANT: pipeline must be object (not string). Use "sort" (not "sortBy"). output is REQUIRED.
-Run help(topic="buffers") for full schema, operators, and examples.`,
-            inputSchema: BufferPipelineInputSchema,
+INPUTS: Map of variable names to buffer IDs. Buffers are loaded as globals.
+CODE: ES2020 JavaScript (synchronous). Return value becomes output buffer(s).
+
+OUTPUT FORMAT:
+- For CONFLUENCE → toTable(), toList() → XHTML
+- For DISPLAY → toMarkdownTable(), toMarkdownList() → Markdown
+
+HELPERS: groupBy, sum, avg, min, max, count, unique, get, pick, omit, parseDate, formatDate, daysBetween
+
+Example:
+  inputs: { issues: "buf_xxx" }
+  code: \`
+    const open = issues.filter(i => i.status !== 'Done');
+    return toMarkdownTable(open, {
+      columns: [
+        { field: 'key', header: 'Issue', link: { type: 'jira' } },
+        { field: 'summary', header: 'Summary' },
+        { field: 'status', header: 'Status' },
+        { field: 'assignee', header: 'Assignee' }
+      ]
+    });
+  \``,
+            inputSchema: BufferTransformInputSchema,
             handler: async (args) => {
                 try {
-                    // Type-safe buffer access: buffer_pipeline requires JSON buffer
-                    const typeError = validateBufferType(args.sourceBufferId, ["json"], "buffer_pipeline");
-                    if (typeError)
-                        return typeError.result;
-                    // 1. Get buffer info
-                    const bufferInfo = contentBuffer.getInfo(args.sourceBufferId);
-                    if (!bufferInfo) {
-                        return formatError({
-                            error: true,
-                            message: `Buffer not found or expired: ${args.sourceBufferId}`,
-                            statusCode: 404,
-                        });
-                    }
-                    // 2. Get buffer content
-                    const chunk = contentBuffer.getChunk(args.sourceBufferId, 0, bufferInfo.bufferSizeBytes);
-                    if (!chunk) {
-                        return formatError({
-                            error: true,
-                            message: `Failed to read buffer content: ${args.sourceBufferId}`,
-                            statusCode: 500,
-                        });
-                    }
-                    // 3. Parse JSON array
-                    let data;
-                    try {
-                        const parsed = JSON.parse(chunk.chunk);
-                        if (!Array.isArray(parsed)) {
+                    // 1. Load all input buffers
+                    const inputData = {};
+                    for (const [name, bufferId] of Object.entries(args.inputs)) {
+                        // Type-safe buffer access: buffer_transform requires JSON buffers
+                        const typeError = validateBufferType(bufferId, ["json"], "buffer_transform");
+                        if (typeError) {
                             return formatError({
                                 error: true,
-                                message: "Buffer content is not a JSON array. buffer_pipeline requires array data.",
+                                message: `Input "${name}": ${typeError.result.content[0].type === "text" ? JSON.parse(typeError.result.content[0].text).message : "Invalid buffer"}`,
                                 statusCode: 400,
-                                details: { type: typeof parsed },
+                                details: { inputName: name, bufferId },
+                            });
+                        }
+                        const bufferInfo = getSessionBuffer().getInfo(bufferId);
+                        if (!bufferInfo) {
+                            return formatError({
+                                error: true,
+                                message: `Input "${name}": Buffer not found or expired: ${bufferId}`,
+                                statusCode: 404,
+                                details: { inputName: name, bufferId },
+                            });
+                        }
+                        const chunk = getSessionBuffer().getChunk(bufferId, 0, bufferInfo.bufferSizeBytes);
+                        if (!chunk) {
+                            return formatError({
+                                error: true,
+                                message: `Input "${name}": Failed to read buffer: ${bufferId}`,
+                                statusCode: 500,
+                                details: { inputName: name, bufferId },
+                            });
+                        }
+                        try {
+                            inputData[name] = JSON.parse(chunk.chunk);
+                        }
+                        catch (e) {
+                            return formatError({
+                                error: true,
+                                message: `Input "${name}": Failed to parse as JSON: ${e.message}`,
+                                statusCode: 400,
+                                details: { inputName: name, bufferId },
                             });
                         }
-                        data = parsed;
-                    }
-                    catch (e) {
-                        return formatError({
-                            error: true,
-                            message: `Failed to parse buffer as JSON: ${e.message}`,
-                            statusCode: 400,
-                        });
                     }
-                    // 4. Build pipeline context
+                    // 2. Build context
                     const context = {
-                        sourceBufferId: args.sourceBufferId,
                         jiraUrl: process.env.JIRA_URL,
                         confluenceUrl: process.env.CONFLUENCE_URL,
-                        metadata: bufferInfo.metadata,
                     };
-                    // 5. Dry run - validate only
-                    if (args.dryRun) {
-                        const validation = validatePipeline(data, args.pipeline);
+                    // 3. Execute in sandbox
+                    const result = await executeTransform({ inputs: args.inputs, code: args.code, limits: args.limits }, context, inputData);
+                    // 4. Handle errors
+                    if ("error" in result && result.error) {
+                        return formatError({
+                            error: true,
+                            message: result.message,
+                            statusCode: result.code === "TIMEOUT" || result.code === "MEMORY_LIMIT" ? 408 : 400,
+                            details: {
+                                code: result.code,
+                                ...result.details,
+                                tip: 'Call help(topic="buffers") for transform syntax and helper functions.',
+                            },
+                        });
+                    }
+                    // 5. Store output(s) as buffer(s)
+                    const transformResult = result;
+                    // Handle multiple outputs
+                    if (transformResult.multipleOutputs) {
+                        const buffers = {};
+                        for (const [outputName, output] of Object.entries(transformResult.multipleOutputs)) {
+                            const bufferId = await storeTransformOutput(output.contentType, output.content, { outputName });
+                            buffers[outputName] = bufferId;
+                        }
                         return formatSuccessDirect({
-                            dryRun: true,
-                            valid: validation.valid,
-                            errors: validation.errors,
-                            warnings: validation.warnings,
-                            availableFields: validation.availableFields,
-                            itemCount: data.length,
+                            buffers,
+                            outputCount: Object.keys(buffers).length,
+                            hint: "Multiple buffers created. Use buffer_get_items(bufferId) to access each.",
                         });
                     }
-                    // 6. Execute pipeline
-                    const pipelineResult = executePipelineWithOutput(data, args.pipeline, context);
-                    if ("error" in pipelineResult) {
-                        return formatError(pipelineResult.error);
+                    // Handle single XHTML output
+                    if (transformResult.xhtmlContent) {
+                        const bufferId = await storeTransformOutput("xhtml", transformResult.xhtmlContent, {});
+                        return formatSuccessDirect({
+                            bufferId,
+                            contentType: "xhtml",
+                            hint: "Use confluence_draft_create(bufferId) to publish, or buffer_edit to modify.",
+                        });
                     }
-                    // 7. Store output in buffer
-                    const { result, output } = pipelineResult;
-                    const outputType = args.pipeline.output.type;
-                    // Determine content type for buffer (csv/markdown stored as JSON wrapper)
-                    const contentType = outputType.startsWith("xhtml")
-                        ? "xhtml"
-                        : "json";
-                    const bufferMetadata = {
-                        contentType,
-                        resourceType: "pipeline_output",
-                        sourceBufferId: args.sourceBufferId,
-                        pipelineStages: result.pipelineStages,
-                        outputType,
-                    };
-                    let newBufferId;
-                    if (contentType === "xhtml") {
-                        // Parse XHTML to get structure with element IDs
-                        const parseResult = parseXhtml(output);
-                        if (parseResult.document) {
-                            const structureResult = parseStructure(parseResult.document);
-                            // Re-serialize to include data-jicon-id attributes
-                            const contentWithIds = serializeXhtml(parseResult.document);
-                            newBufferId = contentBuffer.storeWithStructure(contentWithIds, structureResult.structure, structureResult.nextId, bufferMetadata);
-                        }
-                        else {
-                            // Fallback: store without structure if parsing fails
-                            newBufferId = contentBuffer.store(output, bufferMetadata);
+                    // Handle single Markdown output - return content directly (displayable)
+                    if (transformResult.markdownContent) {
+                        const markdownContent = transformResult.markdownContent;
+                        const bufferId = await storeTransformOutput("markdown", markdownContent, {});
+                        const maxContentSize = Math.floor(getMaxOutputSize() * 0.9);
+                        if (markdownContent.length <= maxContentSize) {
+                            // Return content directly - no extra tool call needed
+                            return formatSuccessDirect({
+                                bufferId,
+                                format: "markdown",
+                                content: markdownContent,
+                            });
                         }
+                        // Truncate large content
+                        return formatSuccessDirect({
+                            bufferId,
+                            format: "markdown",
+                            content: markdownContent.substring(0, maxContentSize) + "\n\n...[truncated]",
+                            truncated: true,
+                            fullSize: markdownContent.length,
+                            note: "Content truncated. Full content available via buffer_get_items(bufferId, keys=['content']).",
+                        });
                     }
-                    else {
-                        // JSON content type - handles json, csv, and markdown outputs
-                        if (outputType === "json") {
-                            // Pure JSON output - parse and store with structure
-                            try {
-                                const data = JSON.parse(output);
-                                const { content: contentWithIds, structure: jsonStruct } = createJsonStructure(data);
-                                newBufferId = contentBuffer.storeJsonWithStructure(contentWithIds, jsonStruct, bufferMetadata);
-                            }
-                            catch {
-                                // Fallback: wrap as JSON object if parsing fails
-                                const wrapperData = { content: output };
-                                const { content: jsonContent, structure: jsonStruct } = createJsonStructure(wrapperData);
-                                newBufferId = contentBuffer.storeJsonWithStructure(jsonContent, jsonStruct, bufferMetadata);
-                            }
-                        }
-                        else {
-                            // CSV/Markdown output - wrap in JSON object for accessor support
-                            const wrapperData = { content: output, format: outputType };
-                            const { content: jsonContent, structure: jsonStruct } = createJsonStructure(wrapperData);
-                            newBufferId = contentBuffer.storeJsonWithStructure(jsonContent, jsonStruct, bufferMetadata);
-                        }
+                    // Handle single JSON output
+                    if (transformResult.jsonContent !== undefined) {
+                        const bufferId = await storeTransformOutput("json", transformResult.jsonContent, {});
+                        return formatSuccessDirect({
+                            bufferId,
+                            contentType: "json",
+                            itemCount: transformResult.itemCount,
+                            hint: "Use buffer_get_items(bufferId) to access data, or buffer_transform for further processing.",
+                        });
                     }
-                    // 8. Return result with bufferId
-                    return formatSuccessDirect({
-                        ...result,
-                        bufferId: newBufferId,
-                        contentType,
+                    // Should not reach here
+                    return formatError({
+                        error: true,
+                        message: "Unexpected transform result: no output generated",
+                        statusCode: 500,
                     });
                 }
                 catch (error) {
@@ -1502,4 +1637,36 @@ Run help(topic="buffers") for full schema, operators, and examples.`,
         },
     };
 }
+/**
+ * Store transform output as a buffer
+ */
+async function storeTransformOutput(contentType, content, metadata) {
+    const bufferMetadata = {
+        contentType,
+        resourceType: "transform_output",
+        ...metadata,
+    };
+    if (contentType === "xhtml") {
+        const xhtmlContent = content;
+        const parseResult = parseXhtml(xhtmlContent);
+        if (parseResult.document) {
+            const structureResult = parseStructure(parseResult.document);
+            const contentWithIds = serializeXhtml(parseResult.document);
+            return getSessionBuffer().storeWithStructure(contentWithIds, structureResult.structure, structureResult.nextId, bufferMetadata);
+        }
+        return getSessionBuffer().store(xhtmlContent, bufferMetadata);
+    }
+    if (contentType === "markdown") {
+        // Store markdown as a JSON wrapper for easy access via buffer_get_items
+        const markdownContent = content;
+        const wrapper = { content: markdownContent, format: "markdown" };
+        const { content: jsonContent, structure: jsonStruct } = createJsonStructure(wrapper);
+        // Override contentType to "json" so buffer_get_items can read it
+        const markdownMetadata = { ...bufferMetadata, contentType: "json", originalType: "markdown" };
+        return getSessionBuffer().storeJsonWithStructure(jsonContent, jsonStruct, markdownMetadata);
+    }
+    // JSON content
+    const { content: jsonContent, structure: jsonStruct } = createJsonStructure(content);
+    return getSessionBuffer().storeJsonWithStructure(jsonContent, jsonStruct, bufferMetadata);
+}
 //# sourceMappingURL=buffer-tools.js.map