json-object-editor 0.10.650 → 0.10.654

package/docs/joe_agent_custom_gpt_instructions_v_3.md

@@ -13,8 +13,8 @@ Note: Use `hydrate {}` to load schema summaries and global datasets. Prefer summ
 - Treat “schema” as “itemtype” (JOE object type). Use `itemtype` in tool params.
 - Reads are autonomous; writes require explicit confirmation.
 - Prefer cache (`search` default) for exploration; use `source:"storage"` for authoritative reads.
-- Keep results scoped (limit 10–25 by default; increase only when needed).
 - Do not expose secrets/tokens; server may sanitize.
+- Use slim to reduce payloads when requesting long lists of objects.
 
 ## Tools
 - listSchemas {}
@@ -31,6 +31,16 @@ Note: Use `hydrate {}` to load schema summaries and global datasets. Prefer summ
     - `related` contains non‑global referenced objects (e.g., ingredient, project, user),
     - `tags` / `statuses` are deduped lookup maps `{ _id, itemtype, name }` for those global types.
   - When looking up by id, call `understandObject` first instead of issuing many separate `getObject` / `getSchema` / `search` calls.
+- **findObjectsByTag { tags, itemtype?, limit?, offset?, source?, slim?, withCount?, countOnly?, tagThreshold? }**
+  - Find objects that have ALL specified tags (AND logic). Tags can be provided as IDs (CUIDs) or names (strings) - names are resolved via fuzzy search.
+  - Returns `{ items, tags, count?, error? }` where `tags` contains the resolved tag objects used in the search.
+  - Use `countOnly: true` to get just the count and matched tags without fetching items.
+  - If a tag cannot be resolved, returns `{ items: [], tags: [...resolved ones...], error: "message" }` instead of throwing.
+- **findObjectsByStatus { status, itemtype?, limit?, offset?, source?, slim?, withCount?, countOnly?, statusThreshold? }**
+  - Find objects by status. Status can be provided as ID (CUID) or name (string) - name is resolved via fuzzy search.
+  - Returns `{ items, status, count?, error? }` where `status` is the resolved status object used in the search.
+  - Use `countOnly: true` to get just the count and matched status without fetching items.
+  - If status cannot be resolved, returns `{ items: [], status: null, error: "message" }` instead of throwing.
 - saveObject { object }
 - saveObjects { objects, stopOnError?, concurrency? }
 
@@ -46,15 +56,59 @@ Note: Use `hydrate {}` to load schema summaries and global datasets. Prefer summ
 
 ## 🧭 When Finding Objects
 
-Example: “List all the conditions in the system.”
+### General Search
+Example: "List all the conditions in the system."
 
-- Identify the itemtype (e.g., `condition`, `client`, `recommendation`, `task`). Do not ask for confirmation if it’s clear.
+- Identify the itemtype (e.g., `condition`, `client`, `recommendation`, `task`). Do not ask for confirmation if it's clear.
 - Search by itemtype using `search`.
 - Use `"slim": true` to limit per‑record data.
 - Return essential fields: `_id`, `itemtype`, `name`, `info`, timestamps (from slim).
 - Sort by `name` ascending.
 - Include `"withCount": true` and a reasonable `"limit"` (e.g., 100–250) for bulk lists.
 
+### Finding by Tags
+Example: "Show me all tasks tagged with 'urgent' and 'bug'."
+
+- Use `findObjectsByTag` when the user explicitly mentions tags or wants to filter by tags.
+- Tags can be provided as names (e.g., `"urgent"`, `"bug"`) or IDs - the function will resolve names via fuzzy search.
+- The function requires ALL tags to be present (AND logic).
+- Check the `tags` array in the response to see which tag objects were matched.
+- If tags cannot be resolved, the response will include an `error` field with details.
+
+Example:
+```json
+{
+  "method": "findObjectsByTag",
+  "params": {
+    "tags": ["urgent", "bug"],
+    "itemtype": "task",
+    "limit": 50,
+    "slim": true
+  }
+}
+```
+
+### Finding by Status
+Example: "List all tasks with status 'In Progress'."
+
+- Use `findObjectsByStatus` when the user explicitly mentions a status or wants to filter by status.
+- Status can be provided as a name (e.g., `"In Progress"`) or ID - the function will resolve names via fuzzy search.
+- Check the `status` object in the response to see which status was matched.
+- If status cannot be resolved, the response will include an `error` field with details.
+
+Example:
+```json
+{
+  "method": "findObjectsByStatus",
+  "params": {
+    "status": "In Progress",
+    "itemtype": "task",
+    "limit": 50,
+    "slim": true
+  }
+}
+```
+
 Example JSON‑RPC:
 
 ```json

package/js/JsonObjectEditor.jquery.craydent.js

@@ -5104,9 +5104,145 @@ this.renderHTMLContent = function(specs){
 		} else if (elem.msRequestFullscreen) { /* IE11 */
 			elem.msRequestFullscreen();
 		}
-    }
+    };
     encapsulateFieldType('code',self.renderCodeField,
     {fullscreen:this.fullScreenCodeEditor});
+
+/*----------------------------->
+ Q.1 | JSON Field
+ <-----------------------------*/
+    this.renderJsonField = function(prop){
+        /*|{
+            tags:'render,field,json',
+            specs:'value,standard_field_properties',
+            description:'JSON object editor using Ace in JSON mode; always pretty-prints on load/blur/save.'
+        }|*/
+        var height = (prop.height)?'style="height:'+prop.height+';"' : '';
+        var editor_id = cuid();
+        var rawValue = (typeof prop.value == "undefined") ? {} : prop.value;
+        var displayValue;
+        // Ensure we start from an object and pretty JSON string
+        if (typeof rawValue == "string") {
+            try{
+                rawValue = JSON.parse(rawValue);
+            }catch(e){
+                // fallback: leave as raw string, Ace/validation will handle parse errors on blur/save
+            }
+        }
+        if (rawValue === null || typeof rawValue == "undefined") {
+            rawValue = {};
+        }
+        if (typeof rawValue == "object") {
+            try{
+                displayValue = JSON.stringify(rawValue,null,2);
+            }catch(e){
+                displayValue = "{}";
+            }
+        }else{
+            // Non-object (number/boolean/etc.) – stringify as-is but still require valid JSON
+            try{
+                displayValue = JSON.stringify(rawValue,null,2);
+            }catch(e){
+                displayValue = "{}";
+            }
+        }
+        var html =
+            '<div class="clear joe-ace-holder joe-rendering-field joe-field" '
+            +height+' data-ace_id="'+editor_id+'" data-ftype="ace" name="'+prop.name+'">'+
+            '<textarea class="" id="'+editor_id+'" >'
+            +(displayValue || "{}")+
+            '</textarea>'+
+            '</div>'+
+        '<script>'+
+            'try{\
+                var editor = ace.edit("'+editor_id+'");\
+                editor.setTheme("ace/theme/tomorrow");\
+                editor.getSession().setUseWrapMode(true);\
+                editor.getSession().setMode("ace/mode/json");\
+                editor.setOptions({\
+                    enableBasicAutocompletion: true,\
+                    enableLiveAutocompletion: false\
+                });\
+                _joe.ace_editors["'+editor_id+'"] = editor;\
+            }catch(e){ console && console.warn && console.warn("ACE json init error",e);}'
+        +' </script>';
+        return html;
+    };
+    // Helper to (re)parse and pretty-print a json field from its Ace editor.
+    function _normalizeJsonField(fieldName,opts){
+        opts = opts || {};
+        var parent = getJoe(self.joe_index);
+        var $holder = parent.overlay.find('.joe-ace-holder[name="'+fieldName+'"]');
+        if(!$holder.length){ return { ok:true }; }
+        var editorId = $holder.data('ace_id');
+        var editor = _joe.ace_editors[editorId];
+        if(!editor){ return { ok:true }; }
+        var text = editor.getValue();
+        if(!text || !text.trim()){
+            // default to empty object
+            text = '{}';
+        }
+        try{
+            var parsed = JSON.parse(text);
+            // must be an object; if not, still allow but keep as-is
+            try{
+                var pretty = JSON.stringify(parsed,null,2);
+                editor.setValue(pretty,-1);
+            }catch(_e){}
+            $holder.removeClass('joe-field-error');
+            return { ok:true, parsed:parsed };
+        }catch(e){
+            // Attempt a light-weight "loose JSON" fix for common cases:
+            //  - Unquoted identifier keys: { name:"Corey" } -> { "name":"Corey" }
+            //  - Single-quoted strings: { "name":'Corey' } -> { "name":"Corey" }
+            //  - Trailing commas: { "a":1, } -> { "a":1 }
+            var fixed = text;
+            try{
+                // Quote bare identifier keys following { or , and before :
+                fixed = fixed.replace(/([{\[],\s*|[{]\s*|,\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g,function(m,prefix,key){
+                    return prefix+'"'+key+'":';
+                });
+                // Convert single-quoted strings to double-quoted strings
+                fixed = fixed.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g,'"$1"');
+                // Remove trailing commas before } or ]
+                fixed = fixed.replace(/,\s*([}\]])/g,'$1');
+
+                var reparsed = JSON.parse(fixed);
+                try{
+                    var prettyFixed = JSON.stringify(reparsed,null,2);
+                    editor.setValue(prettyFixed,-1);
+                }catch(_e2){}
+                $holder.removeClass('joe-field-error');
+                return { ok:true, parsed:reparsed };
+            }catch(_fixErr){
+                $holder.addClass('joe-field-error');
+                if(opts.showMessage && parent.showMessage){
+                    parent.showMessage("Field '"+fieldName+"' must be valid JSON (object).");
+                }
+                return { ok:false, error:e };
+            }
+        }
+    }
+    encapsulateFieldType('json',self.renderJsonField,{
+        ready:function(){
+            // Attach blur handlers to normalize/validate json fields when panel shows
+            var parent = getJoe(self.joe_index);
+            parent.overlay.find('.joe-ace-holder[name]').each(function(){
+                var name = $(this).attr('name');
+                var field = self.getField(name);
+                if(!field){ return true; }
+                var ftype = (self.propAsFuncOrValue(field.type)||'').toLowerCase();
+                if(ftype != 'json'){ return true; }
+                var editorId = $(this).data('ace_id');
+                var editor = _joe.ace_editors[editorId];
+                if(!editor){ return true; }
+                editor.on('blur',function(){
+                    _normalizeJsonField(name,{showMessage:false});
+                });
+            });
+        },
+        normalize:_normalizeJsonField
+    });
 /*----------------------------->
  Q.2 | QR Field
  <-----------------------------*/
@@ -5215,7 +5351,7 @@ this.renderHTMLContent = function(specs){
                     '<div class="joe-uploader-preview">'+dz_message+'</div>'+
                 '</div>'+
                 '<div class="joe-uploader-message">add a file</div>'+
-            '<div class="joe-button joe-green-button joe-upload-cofirm-button hidden"  onclick="_joe.uploaderConfirm(\''+uploader_id+'\',\''+prop.name+'\');">Upload File</div>'+__clearDiv__+
+            '<div class="joe-button joe-green-button joe-upload-cofirm-button ui-helper-hidden hidden"  onclick="_joe.uploaderConfirm(\''+uploader_id+'\',\''+prop.name+'\');">Upload File</div>'+__clearDiv__+
             '</div>'
             ;
         //var idprop = prop.idprop || '_id';
@@ -5242,7 +5378,7 @@ this.renderHTMLContent = function(specs){
         var jup_template,html= '';
         var alink ="<a href='${url}${base64}' class='file-link' target='_blank'></a>";
         var delete_btn = '<joe-uploader-file-delete-btn class="svg-shadow" onclick="_joe.Fields.uploader.remove(\''+cuid+'\',\'${filename}\');">'+self.SVG.icon.close+'</joe-uploader-delete-btn>';
-        var label = '<joe-uploader-file-label>${filename}</joe-uploader-file-label>';
+        var label = '';
         
         
         files.map(function(file){
@@ -5267,6 +5403,12 @@ this.renderHTMLContent = function(specs){
             
             
             
+            // Build the label with filename and optional OpenAI file id on a new line
+            label = '<joe-uploader-file-label>'+(file.filename || '')+'</joe-uploader-file-label>';
+            if(file.openai_file_id){
+                label += '<joe-uploader-file-oaid >'+file.openai_file_id+'</joe-uploader-file-oaid>';
+            }
+
             if((file.type && file.type.contains('image')) || (!file.type && (file.url||file.base64).split('.').contains(['jpg','jpeg','png','gif','svg']))){
                 jup_template = '<joe-uploader-file class="'+(file.uploaded && 'uploaded'||'')+'" style="background-image:url(${url}${base64})">'+alink+label+filesize+delete_btn+'</joe-uploader-file>';
             }else if (docTypes.includes((file.url || file.base64).split('.').pop())) {
@@ -5278,7 +5420,16 @@ this.renderHTMLContent = function(specs){
                 '<joe-uploader-file-extension >.'+(file.type.split('/')[1] || '???')+'</joe-uploader-file-extension>'+
                 alink+label+filesize+delete_btn+'</joe-uploader-file>';
             }    
-            html += fillTemplate(jup_template,file);
+            // Build optional OpenAI retry/upload button
+            var openaiBtn = '';
+            var needRetry = (!file.openai_file_id || file.openai_status == 'error');
+            var hasUrl = !!file.url;
+            if(hasUrl && needRetry){
+                var openaiLabel = (file.openai_status == 'error') ? 'Retry OpenAI' : 'Upload to OpenAI';
+                var safeFilename = (file.filename || '').replace(/'/g,"\\'");
+                openaiBtn = '<joe-uploader-openai-btn class="joe-button" style="margin-left:6px;" onclick="_joe.SERVER.Plugins.openaiRetryFromUrl(\''+cuid+'\',\''+safeFilename+'\');">'+openaiLabel+'</joe-uploader-openai-btn>';
+            }
+            html += fillTemplate(jup_template,file) + openaiBtn;
         })
         return html+'<div class="clear"></div>';
     }
@@ -5295,7 +5446,7 @@ this.renderHTMLContent = function(specs){
                 $(joe_uploader.dropzone).find('img,div').replaceWith('<img src="' + base64 + '">')
                 //joe_uploader.dropzone.html('<img src="' + base64 + '">');
                 joe_uploader.message.html('<b>'+file.name+'</b> selected');
-                joe_uploader.confirmBtn.removeClass('hidden');
+                joe_uploader.confirmBtn.removeClass('ui-helper-hidden hidden');
             }else {
                 results.innerHTML = 'Nothing to upload.';
             }
@@ -5326,7 +5477,7 @@ this.renderHTMLContent = function(specs){
                 }
                 joe_uploader.files.push(temp_file);
                 $(joe_uploader.preview).html(_renderUploaderFilePreviews(joe_uploader.files,joe_uploader.cuid));
-                joe_uploader.confirmBtn.removeClass('hidden');
+                joe_uploader.confirmBtn.removeClass('ui-helper-hidden hidden');
             }else {
                 results.innerHTML = 'Nothing to upload.';
             }
@@ -5394,6 +5545,20 @@ this.renderHTMLContent = function(specs){
                     var fileobj = joe_uploader.files.where({filename:filename})[0];
                     fileobj.uploaded = new Date();
                     fileobj.url = url;
+                    // Apply captured OpenAI info if present
+                    var key = self.current.object._id + '/' + filename;
+                    var oi = _joe._lastOpenAI && _joe._lastOpenAI[key];
+                    fileobj.openai_purpose = 'assistants';
+                    if(oi){
+                        fileobj.openai_file_id = oi.openai_file_id || null;
+                        fileobj.openai_status = (oi.openai_file_id && 'ok') || (oi.openai_error && 'error') || 'not_uploaded';
+                        fileobj.openai_error = oi.openai_error || null;
+                        if(oi.openai_error){
+                            joe_uploader.message.append('<div>OpenAI error: '+oi.openai_error+'</div>');
+                        }
+                    }else{
+                        fileobj.openai_status = fileobj.openai_status || 'not_uploaded';
+                    }
                     delete fileobj.base64;
                 }
 
@@ -5464,6 +5629,14 @@ this.renderHTMLContent = function(specs){
             self.uploaders[id].dropzone = $(this).find('.joe-uploader-dropzone');
             self.uploaders[id].confirmBtn = $(this).find('.joe-upload-cofirm-button');
 
+			// If there are pending files (not uploaded or missing url), show the confirm button
+			var pending = (self.uploaders[id].files || []).some(function(file){
+				return $c.isObject(file) && (!file.uploaded || !file.url);
+			});
+			if(pending){
+				self.uploaders[id].confirmBtn.removeClass('ui-helper-hidden hidden');
+			}
+
         });
     };
         encapsulateFieldType('uploader',self.renderUploaderField,
@@ -7557,6 +7730,11 @@ Field Rendering Helpers
          //ready objectlist
          self.Fields.objectlist.ready();
 
+        //ready json (Ace-based) fields
+        if(self.Fields.json && self.Fields.json.ready){
+            self.Fields.json.ready();
+        }
+
 
         //sidebars
         if(self.current.sidebars){
@@ -7682,10 +7860,26 @@ Field Rendering Helpers
             var f,test_info;
             for(var c in changes){
                 f = self.getField(c);
-                
-
                 if(c[0] != '$' && c != 'joeUpdated' && f && f.type !='content' && !parseBoolean(f.passthrough)){
-                    if(JSON.stringify(_joe.current.object[c]) == JSON.stringify(cc_construct[c])){
+                    // Special handling for json fields: compare parsed objects so
+                    // whitespace/formatting-only changes are ignored.
+                    var ftype = (self.propAsFuncOrValue(f.type)||'').toLowerCase();
+                    if(ftype == 'json'){
+                        var orig = _joe.current.object[c];
+                        var rawNew = cc_construct[c];
+                        var sameJson = false;
+                        try{
+                            var parsedOrig = (typeof orig == "string") ? JSON.parse(orig) : orig;
+                            var parsedNew = (typeof rawNew == "string") ? JSON.parse(rawNew) : rawNew;
+                            sameJson = (JSON.stringify(parsedOrig) == JSON.stringify(parsedNew));
+                        }catch(_e){
+                            // parse failure means it is definitely a change that needs attention
+                            sameJson = false;
+                        }
+                        if(sameJson){
+                            continue;
+                        }
+                    }else if(JSON.stringify(_joe.current.object[c]) == JSON.stringify(cc_construct[c])){
                         continue;
                     }
                     if(['qrcode'].indexOf(f.type) != -1){
@@ -7988,6 +8182,27 @@ Field Rendering Helpers
 		}
 		var callback = callback || self.current.callback || (self.current.schema && self.current.schema.callback) || defaultCallback; //logit;
 		var newObj = self.constructObjectFromFields(self.joe_index);
+		// Normalize json fields: parse to objects and block save on invalid JSON.
+        if(_joe && _joe.current && _joe.current.fields){
+            var jsonField, ftype, normResult;
+            for(var i=0, tot=_joe.current.fields.length; i<tot; i++){
+                jsonField = _joe.current.fields[i];
+                ftype = (self.propAsFuncOrValue(jsonField.type)||'').toLowerCase();
+                if(ftype != 'json'){ continue; }
+                // Ensure editor content is normalized and valid
+                normResult = self.Fields.json && self.Fields.json.normalize
+                    ? self.Fields.json.normalize(jsonField.name,{showMessage:true})
+                    : { ok:true };
+                if(!normResult.ok){
+                    // invalid JSON – do not proceed with save
+                    return false;
+                }
+                // Use parsed object if available; default to {} when missing
+                var parsed = (normResult.parsed || (newObj[jsonField.name] && typeof newObj[jsonField.name] == "object"
+                    ? newObj[jsonField.name] : {}));
+                newObj[jsonField.name] = parsed;
+            }
+        }
 		newObj.joeUpdated = new Date();
         overwrites = overwrites || {};
 		var obj = $.extend(newObj,overwrites);
@@ -9758,6 +9973,13 @@ logit(intent)
                                 url = prefix+response.Key;
                             }
                             var filename = response.Key.replace(self.current.object._id+'/','');
+                            // Stash OpenAI info for use during finalization
+                            _joe._lastOpenAI = _joe._lastOpenAI || {};
+                            _joe._lastOpenAI[response.Key] = {
+                                openai_file_id: response.openai_file_id,
+                                openai_purpose: response.openai_purpose,
+                                openai_error: response.openai_error
+                            };
                             if(field.url_field){
                                 var nprop = {};
                                 _joe.current.object[field.url_field] = url;
@@ -9782,6 +10004,53 @@ logit(intent)
                     file: { base64:data.base64, extension:data.extension, type:data.contentType, filename: (_joe.current.object._id+data.extension), name: (_joe.current.object._id+data.extension) },
                     field: data.field
                 }, callback);
+            },
+            // Retry uploading a specific file to OpenAI using its URL.
+            // Invoked by the uploader row action.
+            openaiRetryFromUrl:function(uploader_id, filename){
+                try{
+                    var joe_uploader = self.uploaders[uploader_id];
+                    if(!joe_uploader){ return alert('Uploader not found'); }
+                    var file = joe_uploader.files.where({filename:filename})[0];
+                    if(!file){ return alert('File not found'); }
+                    if(!file.url){ return alert('No URL to upload to OpenAI'); }
+                    var btn = $(joe_uploader.preview).find("joe-uploader-openai-btn:contains('"+filename+"')");
+                    joe_uploader.message.append('<div>Uploading to OpenAI...</div>');
+                    $.ajax({
+                        url: (location.port && '//'+__jsc.hostname+':'+__jsc.port+'/API/plugin/chatgpt/filesRetryFromUrl/') || '//'+__jsc.hostname+'/API/plugin/chatgpt/filesRetryFromUrl/',
+                        type:'POST',
+                        data:{
+                            url:file.url,
+                            filename:file.filename,
+                            contentType:file.type
+                        },
+                        success:function(resp){
+                            if(resp && resp.success && resp.openai_file_id){
+                                file.openai_file_id = resp.openai_file_id;
+                                file.openai_purpose = resp.openai_purpose || 'assistants';
+                                file.openai_status = 'ok';
+                                file.openai_error = null;
+                                joe_uploader.message.append('<div>OpenAI file attached</div>');
+                            }else{
+                                file.openai_status = 'error';
+                                file.openai_error = (resp && resp.error) || 'Upload failed';
+                                joe_uploader.message.append('<div>OpenAI error: '+(file.openai_error)+'</div>');
+                            }
+                            // Refresh preview to reflect new status/button
+                            $(joe_uploader.preview).html(_renderUploaderFilePreviews(joe_uploader.files,joe_uploader.cuid));
+                            // Save object so file metadata is persisted
+                            self.updateObject(null, null, true);
+                        },
+                        error:function(xhr,status,err){
+                            var message = (xhr && (xhr.responseJSON && (xhr.responseJSON.error || xhr.responseJSON.code) || xhr.responseText)) || err || status || 'Retry failed';
+                            file.openai_status = 'error';
+                            file.openai_error = message;
+                            joe_uploader.message.append('<div>OpenAI error: '+message+'</div>');
+                        }
+                    });
+                }catch(e){
+                    alert(e && e.message || e);
+                }
             }
         },
         ready:{
@@ -10679,7 +10948,9 @@ logit(intent)
 /*-------------------------------------------------------------------->
      //Colors
 <--------------------------------------------------------------------*/
-    this.Colors={}
+    this.Colors={
+        "ai":"#0D9488"
+    }
     this.Colors.priority = {
         1:'#cc4500',
         2:'#FFee33',