json-object-editor 0.10.664 → 0.10.668

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.664",
+  "version": "0.10.668",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {

package/server/plugins/chatgpt.js

@@ -887,6 +887,7 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
     // in markdown fences (```json ... ```), and may prepend/append prose. This
     // helper strips fences and tries to isolate the first well-formed JSON
     // object/array substring so JSON.parse has the best chance of succeeding.
+    // Handles cases where tool call logs are concatenated before the actual JSON.
     function extractJsonText(raw) {
         if (!raw) { return ''; }
         let t = String(raw).trim();
@@ -906,19 +907,100 @@ function shrinkUnderstandObjectMessagesForTokens(messages) {
             }
             t = t.trim();
         }
-        // If there's extra prose around the JSON, slice from first {/[ to last }/]
+        
+        // Handle cases where tool call logs (small JSON objects like {"tool":"..."}) 
+        // are concatenated before the actual response JSON (larger JSON object).
+        // Find all JSON objects and pick the largest one that's not a tool log.
+        const jsonCandidates = [];
+        const firstBrace = t.indexOf('{');
+        const firstBracket = t.indexOf('[');
+        const lastBrace = Math.max(t.lastIndexOf('}'), t.lastIndexOf(']'));
+        
+        if (firstBrace === -1 && firstBracket === -1) {
+            return '';
+        }
+        
+        const startPos = (firstBrace === -1) ? firstBracket : 
+                        ((firstBracket === -1) ? firstBrace : Math.min(firstBrace, firstBracket));
+        
+        if (startPos === -1 || lastBrace === -1 || lastBrace <= startPos) {
+            return t.trim();
+        }
+        
+        // Find all potential JSON objects
+        for (let i = startPos; i <= lastBrace; i++) {
+            if (t[i] !== '{' && t[i] !== '[') continue;
+            
+            // Find matching closing brace/bracket
+            let depth = 0;
+            let inString = false;
+            let escape = false;
+            let endPos = -1;
+            
+            for (let j = i; j <= lastBrace; j++) {
+                const char = t[j];
+                if (escape) {
+                    escape = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escape = true;
+                    continue;
+                }
+                if (char === '"') {
+                    inString = !inString;
+                    continue;
+                }
+                if (!inString) {
+                    if (char === '{' || char === '[') {
+                        depth++;
+                    } else if (char === '}' || char === ']') {
+                        depth--;
+                        if (depth === 0) {
+                            endPos = j;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            if (endPos !== -1) {
+                const candidate = t.substring(i, endPos + 1);
+                // Skip tool call logs - they match pattern {"tool":"..."}
+                const isToolLog = /^\s*{\s*"tool"\s*:/.test(candidate);
+                try {
+                    JSON.parse(candidate);
+                    jsonCandidates.push({
+                        text: candidate,
+                        length: candidate.length,
+                        isToolLog: isToolLog
+                    });
+                } catch (e) {
+                    // Not valid JSON, skip
+                }
+            }
+        }
+        
+        // Find the largest non-tool-log JSON object, or largest overall if all are tool logs
+        if (jsonCandidates.length > 0) {
+            // Filter out tool logs first
+            const nonToolLogs = jsonCandidates.filter(c => !c.isToolLog);
+            const candidatesToUse = nonToolLogs.length > 0 ? nonToolLogs : jsonCandidates;
+            
+            // Sort by length (descending) and return the largest
+            candidatesToUse.sort((a, b) => b.length - a.length);
+            return candidatesToUse[0].text.trim();
+        }
+        
+        // Fallback: try simple first-to-last extraction
         if (t[0] !== '{' && t[0] !== '[') {
-            const firstBrace = t.indexOf('{');
-            const firstBracket = t.indexOf('[');
-            let first = -1;
-            if (firstBrace === -1) { first = firstBracket; }
-            else if (firstBracket === -1) { first = firstBrace; }
-            else { first = Math.min(firstBrace, firstBracket); }
-            const lastBrace = Math.max(t.lastIndexOf('}'), t.lastIndexOf(']'));
-            if (first !== -1 && lastBrace !== -1 && lastBrace > first) {
-                t = t.slice(first, lastBrace + 1);
+            const first = startPos;
+            const last = lastBrace;
+            if (first !== -1 && last !== -1 && last > first) {
+                t = t.slice(first, last + 1);
             }
         }
+        
         return t.trim();
     }
 
@@ -1357,9 +1439,27 @@ this.executeJOEAiPrompt = async function(data, req, res) {
 
         // const response = await openai.chat.completions.create(payload);
 
+        // Extract JSON from response to strip tool logs, reasoning text, and other non-JSON content.
+        // This is critical for prompts that explicitly require JSON-only output.
+        const rawResponseText = response.output_text || "";
+        let cleanedResponseText = rawResponseText;
+        try {
+            const extractedJson = extractJsonText(rawResponseText);
+            if (extractedJson && extractedJson.trim().length > 0) {
+                // Validate it's actually valid JSON
+                JSON.parse(extractedJson);
+                cleanedResponseText = extractedJson;
+            }
+        } catch (e) {
+            // If extraction fails or JSON is invalid, fall back to raw text
+            // (some prompts may not be JSON-formatted)
+            console.warn('[chatgpt.executeJOEAiPrompt] Failed to extract JSON from response, using raw text:', e.message);
+        }
+
         const saved = await saveAiResponseRefactor({
             prompt,
-            ai_response_content: response.output_text || "",
+            ai_response_content: cleanedResponseText,
+            ai_response_raw: rawResponseText,
             user_prompt: finalInput || '',
             params,
             referenced_object_ids: referencedObjectIds,
@@ -1382,7 +1482,7 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             }
         }catch(_e){}
 
-        return { success: true, ai_response_id: saved._id,response:response.output_text || "",usage:response.usage };
+        return { success: true, ai_response_id: saved._id,response:cleanedResponseText,usage:response.usage };
     } catch (e) {
         console.error('❌ executeJOEAiPrompt error:', e);
         return { error: "Failed to execute AI prompt.",message: e.message };
@@ -1402,7 +1502,7 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             max_tokens: prompt.max_tokens ?? 1200
         };
     }
-    async function saveAiResponseRefactor({ prompt, ai_response_content, user_prompt, params, referenced_object_ids,response_id,usage,user,ai_assistant_id, mcp_enabled, mcp_toolset, mcp_selected_tools, mcp_instructions_mode, mcp_tools_used }) {
+    async function saveAiResponseRefactor({ prompt, ai_response_content, ai_response_raw, user_prompt, params, referenced_object_ids,response_id,usage,user,ai_assistant_id, mcp_enabled, mcp_toolset, mcp_selected_tools, mcp_instructions_mode, mcp_tools_used }) {
         var response_keys = [];
         try {
             response_keys = Object.keys(JSON.parse(ai_response_content));
@@ -1437,6 +1537,7 @@ this.executeJOEAiPrompt = async function(data, req, res) {
             prompt_name: prompt.name,
             prompt_method:prompt.prompt_method,
             response: ai_response_content,
+            response_raw: ai_response_raw || null,
             response_json: parsedResponse,
             response_keys: response_keys,
             response_id:response_id||'',

package/server/schemas/ai_prompt.js

@@ -98,8 +98,19 @@ var schema = {
        'name',
         'info',
         {name:"prompt_method",placeholder:"name of method to call in plugin", comment:'use executeJOEAiPrompt to use the JOE ui here for all smarts', default:"executeJOEAiPrompt",display:"Prompt Plugin Method",type:'text'},
-        {name:'content_items',type:'objectList',
-            properties:['itemtype','reference']
+        {name:'content_items',type:'objectList',display:'Content Items',
+            properties:['itemtype','reference'],
+            comment:`
+                <div>
+                    <p>Define which objects are automatically passed when running this prompt via <code>select_prompt</code>.</p>
+                    <ul>
+                        <li><b><code>itemtype</code></b> - Schema name (e.g., <code>"task"</code>)</li>
+                        <li><b><code>reference</code></b> - Parameter name for the object's <code>_id</code> (e.g., <code>"task"</code>)</li>
+                    </ul>
+                    <p>When running from a matching object: <code>params[reference]</code> = object <code>_id</code>, <code>content_objects[itemtype]</code> = full object (available in helper functions).</p>
+                    <p><b>Note:</b> Only objects matching the current object's <code>itemtype</code> are auto-passed. For multiple objects, call programmatically or load in helper functions.</p>
+                </div>
+            `
         },
         {section_start:'Input'},
             {name: 'functions', type: 'code', display: 'Helper Functions', language:'javascript',comment: `

package/server/schemas/ai_response.js

@@ -30,6 +30,7 @@ var schema = {
             { name:'model_used', type:'string' },
             { name:'response_type', type:'string' },
             { name:'response', type:'string' },
+            { name:'response_raw', type:'string' },
             { name:'response_json', type:'object' },
             { name:'response_keys', type:'string', isArray:true },
             { name:'response_id', type:'string' },

package/web-components/joe-workflow-widget.js

@@ -0,0 +1,314 @@
+class JoeWorkflowWidget extends HTMLElement {
+  constructor() {
+    super();
+    this.updateTimer = null;
+    this._rendering = false;
+    this._renderScheduled = false;
+    this.config = this.getDefaultConfig();
+    this.joeIndex = null;
+    this.widgetFieldName = null;
+    this._liveObj = null; // constructed snapshot for live completion when autoUpdate enabled
+  }
+
+  static get observedAttributes() {
+    return ['schema', '_id'];
+  }
+
+  connectedCallback() {
+    this.schemaName = this.getAttribute('schema');
+    this.objectId = this.getAttribute('_id');
+    this.classList.add('joe-workflow-widget');
+    
+    // Get workflow config from field definition
+    this.workflowField = this.closest('.joe-object-field');
+    if (this.workflowField) {
+      var fieldName = this.workflowField.getAttribute('data-name');
+      this.widgetFieldName = fieldName;
+      if (fieldName && window._joe) {
+        var fieldDef = window._joe.getField(fieldName);
+        this.config = (fieldDef && fieldDef.workflow_config) || this.getDefaultConfig();
+      }
+    }
+    
+    this.config = this.config || this.getDefaultConfig();
+
+    // Determine joeIndex for navigation and updates
+    try{
+      var overlay = this.closest('.joe-overlay');
+      if(overlay && overlay.getAttribute('data-joeindex') !== null){
+        this.joeIndex = parseInt(overlay.getAttribute('data-joeindex'), 10);
+        if(isNaN(this.joeIndex)){ this.joeIndex = null; }
+      }
+    }catch(e){}
+    
+    // Get schema name from JOE if not provided
+    if (!this.schemaName && window._joe && window._joe.current && window._joe.current.schema) {
+      this.schemaName = window._joe.current.schema.__schemaname || window._joe.current.schema.name;
+    }
+    
+    this.scheduleRender();
+    this.setupUpdateListener();
+  }
+
+  getDefaultConfig() {
+    return {
+      sections: 'all',
+      fields: 'all',
+      excludeSections: ['system'],
+      excludeFields: ['_id', 'created', 'joeUpdated', 'itemtype', 'tags', 'status'],
+      mustBeTrue: [],
+      autoUpdate: false  // Disabled by default to prevent lockups
+    };
+  }
+
+  setupUpdateListener() {
+    // Only set up listeners if autoUpdate is enabled
+    if (!this.config || !this.config.autoUpdate) {
+      return;
+    }
+
+    // Simplest live update (no tech debt):
+    // On change, compute a constructed snapshot once (debounced) and re-render from that.
+    // Critically, we never call _jco(true) from render() to avoid re-entrancy loops.
+    if(this.joeIndex === null || !window.getJoe){ return; }
+    var self = this;
+    var overlay = this.closest('.joe-overlay');
+    if(!overlay){ return; }
+    this._onFormChange = function(ev){
+      if(ev && ev.target && self.contains(ev.target)){ return; }
+      clearTimeout(self.updateTimer);
+      self.updateTimer = setTimeout(function(){
+        try{
+          var j = getJoe(self.joeIndex);
+          self._liveObj = (j && j.constructObjectFromFields) ? j.constructObjectFromFields(self.joeIndex) : null;
+        }catch(e){
+          self._liveObj = null;
+        }
+        self.scheduleRender();
+      }, 350);
+    };
+    overlay.addEventListener('change', this._onFormChange, true);
+  }
+
+  disconnectedCallback() {
+    try{
+      var overlay = this.closest('.joe-overlay');
+      if(overlay && this._onFormChange){
+        overlay.removeEventListener('change', this._onFormChange, true);
+      }
+    }catch(e){}
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+    }
+  }
+
+  attributeChangedCallback(attr, oldValue, newValue) {
+    if (oldValue !== newValue) {
+      if (attr === 'schema') {
+        this.schemaName = newValue;
+      } else if (attr === '_id') {
+        this.objectId = newValue;
+      }
+      this.scheduleRender();
+    }
+  }
+
+  scheduleRender() {
+    if (this._renderScheduled) {
+      return;
+    }
+    this._renderScheduled = true;
+    var self = this;
+    // Defer to avoid re-entrancy with JOE render/construct cycles
+    setTimeout(function() {
+      self._renderScheduled = false;
+      self.render();
+    }, 0);
+  }
+
+  render() {
+    var self = this;
+    if (this._rendering) {
+      return;
+    }
+    this._rendering = true;
+    var joe = window._joe;
+    if (!joe || !joe.current) {
+      this.innerHTML = '<div class="joe-workflow-error">Workflow widget requires active JOE instance</div>';
+      this._rendering = false;
+      return;
+    }
+
+    var fields = joe.current.fields || [];
+    var sections = joe.current.sections || {};
+    // IMPORTANT: Do NOT call _jco(true) here. It triggers constructObjectFromFields which can
+    // cause re-entrant rerenders / attributeChangedCallback loops and lock up the UI.
+    // Use the live object snapshot. (When autoUpdate is re-enabled later, we can switch to a safer source.)
+    var currentObj = this._liveObj || joe.current.object || {};
+    
+    // Filter sections to show
+    var sectionsToShow = [];
+    if (this.config.sections === 'all') {
+      for (var secId in sections) {
+        if (this.config.excludeSections && this.config.excludeSections.indexOf(secId) !== -1) continue;
+        if (secId === 'system') continue;
+        if (!sections[secId] || !sections[secId].fields || !sections[secId].fields.length) continue;
+        sectionsToShow.push(secId);
+      }
+    } else if (Array.isArray(this.config.sections)) {
+      sectionsToShow = this.config.sections.filter(function(secId) {
+        return sections[secId] && 
+               (!self.config.excludeSections || self.config.excludeSections.indexOf(secId) === -1);
+      });
+    }
+
+    // Calculate progress for each section
+    var sectionProgress = {};
+    sectionsToShow.forEach(function(sectionId) {
+      var section = sections[sectionId];
+      if (!section) return;
+
+      var fieldsInSection = section.fields || [];
+      if (fieldsInSection.length === 0) return;
+
+      var completed = 0;
+      var totalCount = 0;
+      var missing = [];
+      fieldsInSection.forEach(function(fname) {
+        var field = joe.getField(fname) || { name: fname, type: 'text' };
+        var ftype = (joe.propAsFuncOrValue && joe.propAsFuncOrValue(field.type, currentObj)) || field.type || 'text';
+        ftype = (ftype || '').toString().toLowerCase();
+        // Never include content fields in completion counts (widgets, labels, etc).
+        if(ftype === 'content'){ return; }
+        if(self.config.excludeFields && self.config.excludeFields.indexOf(field.name) !== -1){ return; }
+        if(self.config.fields === 'requiredOnly' && !joe.propAsFuncOrValue(field.required, currentObj)){ return; }
+        if(field.hidden && joe.propAsFuncOrValue(field.hidden, currentObj)){ return; }
+        if(field.condition && !joe.propAsFuncOrValue(field.condition, currentObj)){ return; }
+        totalCount++;
+        if (self.isFieldComplete(field, currentObj)) {
+          completed++;
+        }else{
+          missing.push(field.display || field.label || field.name);
+        }
+      });
+
+      if(!totalCount){ return; }
+      var percentage = Math.round((completed / totalCount) * 100);
+      sectionProgress[sectionId] = {
+        name: section.name || sectionId,
+        completed: completed,
+        total: totalCount,
+        percentage: percentage,
+        isComplete: percentage === 100,
+        anchor: section.anchor || sectionId,
+        missing: missing
+      };
+    });
+
+    // Render widget HTML
+    var widgetTitle = this.config.title;
+    if (!widgetTitle && this.schemaName) {
+      // Capitalize first letter of schema name
+      widgetTitle = (this.schemaName.charAt(0).toUpperCase() + this.schemaName.slice(1)) + ' Workflow';
+    }
+    if (!widgetTitle) {
+      widgetTitle = 'Workflow'; // fallback
+    }
+    var html = '<div class="joe-workflow-widget-header">' + widgetTitle + '</div>';
+
+    var hasSections = false;
+    sectionsToShow.forEach(function(sectionId) {
+      var progress = sectionProgress[sectionId];
+      if (!progress) return;
+      hasSections = true;
+
+      var statusHtml = progress.isComplete 
+        ? '<span class="joe-workflow-checkmark" title="Complete">✓</span>'
+        : '<span class="joe-workflow-percentage" title="' + progress.completed + ' of ' + progress.total + ' fields complete">' + progress.percentage + '%</span>';
+
+      var ji = (self.joeIndex !== null ? self.joeIndex : 0);
+      var safeSectionIdHtml = (sectionId || '').toString()
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;');
+      // Use double-quotes inside gotoSection(...) to avoid JS escaping issues.
+      var clickAction = 'onclick="try{ getJoe(' + ji + ').gotoSection(&quot;' + safeSectionIdHtml + '&quot;); }catch(e){}" style="cursor:pointer;"';
+
+      var tip = '';
+      if(progress.missing && progress.missing.length){
+        tip = progress.missing.join(' | ')
+          .replace(/&/g, '&amp;')
+          .replace(/"/g, '&quot;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;');
+      }
+
+      html += '<div class="joe-workflow-section" ' + clickAction + (tip ? (' title="' + tip + '"') : '') + '>';
+      html += '<div class="joe-workflow-section-label">' + progress.name + '</div>';
+      html += '<div class="joe-workflow-section-status">' + statusHtml + '</div>';
+      html += '</div>';
+    });
+
+    if (!hasSections) {
+      html += '<div class="joe-workflow-empty">No sections to track</div>';
+    }
+
+    this.innerHTML = html;
+    this._rendering = false;
+  }
+
+  isFieldComplete(field, obj) {
+    var value = obj[field.name];
+    var fieldType = (field.type || '').toLowerCase();
+    var mustBeTrue = this.config.mustBeTrue && Array.isArray(this.config.mustBeTrue) 
+                     && this.config.mustBeTrue.indexOf(field.name) !== -1;
+
+    if (value === undefined || value === null) {
+      return false;
+    }
+
+    switch (fieldType) {
+      case 'text':
+      case 'rendering':
+      case 'code':
+      case 'wysiwyg':
+      case 'url':
+        return typeof value === 'string' && value.trim().length > 0;
+
+      case 'objectreference':
+        return Array.isArray(value) ? value.length > 0 : !!value;
+
+      case 'objectlist':
+        return Array.isArray(value) && value.length > 0;
+
+      case 'number':
+        return typeof value === 'number' && !isNaN(value);
+
+      case 'boolean':
+        if (mustBeTrue) {
+          return value === true;
+        }
+        return typeof value === 'boolean';
+
+      case 'date':
+      case 'date-time':
+        return !!value;
+
+      case 'select':
+        return value !== '' && value !== null && value !== undefined;
+
+      case 'uploader':
+        return Array.isArray(value) && value.length > 0;
+
+      default:
+        if (Array.isArray(value)) {
+          return value.length > 0;
+        }
+        if (typeof value === 'object') {
+          return Object.keys(value).length > 0;
+        }
+        return !!value;
+    }
+  }
+}
+
+window.customElements.define('joe-workflow-widget', JoeWorkflowWidget);