@pdtf/schemas 3.4.1-6 → 3.4.1-8

package/src/utils/extractOverlay.js

@@ -29,25 +29,58 @@ const extractFields = [
 
 const flattenSkeleton = (schema) => {
   if (!schema) return undefined;
+  
+  // Handle arrays - mark with special notation
+  if (schema.type === "array" && schema.items) {
+    const itemSchema = flattenSkeleton(schema.items);
+    // Use array notation to indicate this is an array
+    return [itemSchema];
+  }
+  
+  // Handle primitives - return type indicator
+  if (schema.type && !schema.properties && !schema.oneOf && !schema.items) {
+    // Return a type indicator for primitive types
+    if (schema.type === "string") return "string";
+    if (schema.type === "number") return "number";
+    if (schema.type === "integer") return "integer";
+    if (schema.type === "boolean") return "boolean";
+    if (schema.type === "null") return "null";
+  }
+  
   let returnStructure = {};
+  
+  // Handle object properties
   if (schema.properties) {
     Object.keys(schema.properties).forEach((key) => {
       returnStructure[key] = flattenSkeleton(schema.properties[key]);
     });
   }
+  
+  // Handle oneOf - merge all possible properties
   if (schema.oneOf) {
     schema.oneOf.forEach((aOneOf) => {
       if (aOneOf.properties) {
         Object.entries(aOneOf.properties).forEach(([key, value]) => {
-          returnStructure[key] = flattenSkeleton(value);
+          // If property already exists and differs, mark as variant
+          const newValue = flattenSkeleton(value);
+          if (returnStructure[key] && JSON.stringify(returnStructure[key]) !== JSON.stringify(newValue)) {
+            // For primitive types, just mark as variant type
+            if (typeof returnStructure[key] === "string" || typeof newValue === "string") {
+              returnStructure[key] = "variant";
+            } else {
+              // For complex types, merge properties
+              returnStructure[key] = { ...returnStructure[key], ...newValue, _variants: true };
+            }
+          } else {
+            returnStructure[key] = newValue;
+          }
         });
       }
     });
   }
-  if (schema.items) {
-    returnStructure = flattenSkeleton(schema.items);
-  }
-  return returnStructure;
+  
+  // Return empty object for objects without properties
+  return Object.keys(returnStructure).length > 0 ? returnStructure : {};
 };
 
 const extractOverlay = (sourceSchema, ref) => {
@@ -197,3 +230,61 @@ fs.writeFileSync(
   JSON.stringify(skeletonSchemaFlattened, null, 2)
 );
 console.log("Flat Skeleton schema written to ../schemas/v3/skeleton.json");
+
+// Generate compact skeleton format for better token efficiency
+const toCompact = (obj, indent = "") => {
+  if (typeof obj === "string") {
+    // Skip type indicators entirely
+    return "";
+  }
+  
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    // Array with content
+    const inner = toCompact(obj[0], indent);
+    if (inner === "") {
+      return "[]"; // Array of primitives
+    }
+    return `[\n${inner}\n${indent}]`;
+  }
+  
+  if (obj && typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "";
+    
+    // Process each key
+    const lines = [];
+    keys.forEach(k => {
+      const val = toCompact(obj[k], indent + "  ");
+      
+      if (val === "") {
+        // Leaf node - just show the property name
+        lines.push(`${indent}  ${k}`);
+      } else if (val === "[]") {
+        // Array property
+        lines.push(`${indent}  ${k}[]`);
+      } else if (val.startsWith("[")) {
+        // Array with nested content - simple concatenation
+        lines.push(`${indent}  ${k}${val}`);
+      } else {
+        // Object property - show name on its own line, content below
+        lines.push(`${indent}  ${k}`);
+        lines.push(val);
+      }
+    });
+    
+    return lines.length > 0 ? lines.join("\n") : "";
+  }
+  
+  return "";
+};
+
+// Since toCompact returns lines without wrapping braces, add them for the root
+const innerContent = toCompact(skeletonSchemaFlattened, "");
+const compactSkeleton = innerContent ? innerContent : "";
+
+fs.writeFileSync(
+  "../schemas/v3/compactSkeleton.txt",
+  compactSkeleton
+);
+console.log("Compact Skeleton written to ../schemas/v3/compactSkeleton.txt");

package/src/utils/minimalSkeleton.js

@@ -0,0 +1,85 @@
+const fs = require("fs");
+
+// Read the current skeleton
+const skeleton = require("../schemas/v3/skeleton.json");
+
+// Ultra-minimal format: use indentation only, no brackets
+const toMinimal = (obj, prefix = "", isArrayItem = false) => {
+  const lines = [];
+  
+  if (typeof obj === "string") {
+    // Type indicators - single letter
+    const typeMap = {
+      "string": "s",
+      "number": "n", 
+      "integer": "i",
+      "boolean": "b",
+      "variant": "v"
+    };
+    return typeMap[obj] || obj;
+  }
+  
+  if (Array.isArray(obj)) {
+    lines.push(prefix + "[]");
+    if (obj.length > 0) {
+      const itemLines = toMinimal(obj[0], prefix + "  ", true);
+      lines.push(...(Array.isArray(itemLines) ? itemLines : [itemLines]));
+    }
+    return lines;
+  }
+  
+  if (obj && typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return prefix + "{}";
+    }
+    
+    keys.forEach((key, index) => {
+      const val = obj[key];
+      const keyPrefix = prefix + key;
+      
+      if (typeof val === "string") {
+        const type = toMinimal(val);
+        lines.push(keyPrefix + ":" + type);
+      } else if (Array.isArray(val)) {
+        const arrLines = toMinimal(val, keyPrefix);
+        lines.push(...arrLines);
+      } else if (val && typeof val === "object" && Object.keys(val).length > 0) {
+        lines.push(keyPrefix);
+        const subLines = toMinimal(val, prefix + "  ");
+        lines.push(...(Array.isArray(subLines) ? subLines : [subLines]));
+      } else {
+        lines.push(keyPrefix);
+      }
+    });
+    
+    return lines;
+  }
+  
+  return prefix + String(obj);
+};
+
+// Generate minimal version
+const minimalLines = toMinimal(skeleton);
+const minimal = minimalLines.join("\n");
+
+// Write minimal version
+fs.writeFileSync("../schemas/v3/minimalSkeleton.txt", minimal);
+
+console.log("Minimal skeleton written to ../schemas/v3/minimalSkeleton.txt");
+console.log(`Size: ${minimal.length} bytes`);
+console.log(`Lines: ${minimalLines.length}`);
+
+// Count tokens
+try {
+  const GPT3Encoder = require('gpt-3-encoder');
+  const encoded = GPT3Encoder.encode(minimal);
+  console.log(`Tokens (GPT-3): ${encoded.length}`);
+  console.log(`Reduction: ${((1 - encoded.length / 78734) * 100).toFixed(1)}% fewer tokens than JSON skeleton`);
+  
+  // Show sample
+  console.log("\nFirst 20 lines:");
+  console.log(minimalLines.slice(0, 20).join("\n"));
+} catch (e) {
+  console.log(`Estimated tokens: ~${Math.ceil(minimal.length / 4)}`);
+}

package/src/utils/pathSkeleton.js

@@ -0,0 +1,181 @@
+const fs = require("fs");
+const traverse = require("traverse");
+
+const combinedSchema = require("../schemas/v3/combined.json");
+
+// Extract fields that have overlay-specific properties
+const extractFields = [
+  "baspi4", "baspi5", "nts", "nts2", "ntsl", "ntsl2",
+  "ta6", "ta7", "ta10", "lpe1", "fme1", "piq",
+  "con29R", "con29DW", "llc1", "rds", "oc1", "sr24",
+];
+
+// Delete properties we don't want in the skeleton
+const deleteProperties = (sourceSchema, propertyNames) => {
+  traverse(sourceSchema).forEach(function (element) {
+    if (propertyNames.includes(this.key)) {
+      this.delete(true);
+    }
+  });
+  return sourceSchema;
+};
+
+// Collect all paths in path notation
+const collectPaths = (schema, currentPath = "") => {
+  const paths = [];
+  
+  if (!schema || typeof schema !== 'object') {
+    return paths;
+  }
+  
+  // Handle arrays
+  if (schema.type === "array" && schema.items) {
+    const arrayPath = currentPath + "[]";
+    paths.push(arrayPath);
+    // Continue with items
+    const itemPaths = collectPaths(schema.items, arrayPath);
+    paths.push(...itemPaths);
+    return paths;
+  }
+  
+  // Handle primitives - add type suffix
+  if (schema.type && !schema.properties && !schema.oneOf && !schema.items) {
+    let typeChar = "";
+    switch(schema.type) {
+      case "string": typeChar = ":s"; break;
+      case "number": typeChar = ":n"; break;
+      case "integer": typeChar = ":i"; break;
+      case "boolean": typeChar = ":b"; break;
+      default: typeChar = "";
+    }
+    if (currentPath) {
+      paths.push(currentPath + typeChar);
+    }
+    return paths;
+  }
+  
+  // Handle objects with properties
+  if (schema.properties) {
+    // If this is an object without a path yet, don't add it
+    if (currentPath && !schema.type?.includes("array")) {
+      paths.push(currentPath);
+    }
+    
+    Object.keys(schema.properties).forEach((propName) => {
+      const newPath = currentPath ? `${currentPath}.${propName}` : propName;
+      const propPaths = collectPaths(schema.properties[propName], newPath);
+      paths.push(...propPaths);
+    });
+  }
+  
+  // Handle oneOf - collect all possible properties
+  if (schema.oneOf) {
+    const variantProps = new Set();
+    schema.oneOf.forEach((oneOfSchema) => {
+      if (oneOfSchema.properties) {
+        Object.keys(oneOfSchema.properties).forEach((propName) => {
+          variantProps.add(propName);
+        });
+      }
+    });
+    
+    // Process each unique property
+    variantProps.forEach((propName) => {
+      const newPath = currentPath ? `${currentPath}.${propName}` : propName;
+      // Check if all variants have the same type
+      let commonType = null;
+      let isVariant = false;
+      
+      schema.oneOf.forEach((oneOfSchema) => {
+        if (oneOfSchema.properties && oneOfSchema.properties[propName]) {
+          const propType = oneOfSchema.properties[propName].type;
+          if (commonType === null) {
+            commonType = propType;
+          } else if (commonType !== propType) {
+            isVariant = true;
+          }
+        }
+      });
+      
+      if (isVariant || !commonType) {
+        paths.push(newPath + ":v"); // variant
+      } else {
+        // Process the first variant's version of this property
+        for (const oneOfSchema of schema.oneOf) {
+          if (oneOfSchema.properties && oneOfSchema.properties[propName]) {
+            const propPaths = collectPaths(oneOfSchema.properties[propName], newPath);
+            paths.push(...propPaths);
+            break;
+          }
+        }
+      }
+    });
+  }
+  
+  // Empty objects
+  if (currentPath && !schema.properties && !schema.oneOf && !schema.items && !schema.type) {
+    paths.push(currentPath);
+  }
+  
+  return paths;
+};
+
+// Remove duplicates
+const deduplicatePaths = (paths) => {
+  return [...new Set(paths)];
+};
+
+// Sort paths for readability
+const sortPaths = (paths) => {
+  return paths.sort((a, b) => {
+    // Sort by depth first (fewer dots = higher up)
+    const depthA = (a.match(/\./g) || []).length;
+    const depthB = (b.match(/\./g) || []).length;
+    if (depthA !== depthB) return depthA - depthB;
+    
+    // Then alphabetically
+    return a.localeCompare(b);
+  });
+};
+
+// Create clean schema
+const coreSchema = deleteProperties(JSON.parse(JSON.stringify(combinedSchema)), [
+  "discriminator",
+  ...extractFields.map((item) => `${item}Ref`),
+  ...extractFields.map((item) => `${item}Required`),
+  ...extractFields.map((item) => `${item}Title`),
+  ...extractFields.map((item) => `${item}Description`),
+  ...extractFields.map((item) => `${item}Enum`),
+]);
+
+// Remove metadata
+const skeletonSchema = deleteProperties(coreSchema, [
+  "$schema", "$id", "title", "description", "required",
+  "enum", "minItems", "minLength", "format", "minimum", "maximum",
+]);
+
+// Collect paths
+const allPaths = collectPaths(skeletonSchema);
+const uniquePaths = deduplicatePaths(allPaths);
+const sortedPaths = sortPaths(uniquePaths);
+
+// Write as text file
+const pathContent = sortedPaths.join('\n');
+fs.writeFileSync("../schemas/v3/pathSkeleton.txt", pathContent);
+
+// Also create a JSON version for comparison
+fs.writeFileSync("../schemas/v3/pathSkeleton.json", JSON.stringify(sortedPaths, null, 2));
+
+console.log(`Path skeleton written to ../schemas/v3/pathSkeleton.txt`);
+console.log(`Total paths: ${sortedPaths.length}`);
+console.log(`Text size: ${pathContent.length} bytes`);
+
+// Count tokens
+try {
+  const GPT3Encoder = require('gpt-3-encoder');
+  const encoded = GPT3Encoder.encode(pathContent);
+  console.log(`Tokens (GPT-3): ${encoded.length}`);
+  console.log(`Reduction: ${((1 - encoded.length / 78734) * 100).toFixed(1)}% fewer tokens than JSON skeleton`);
+} catch (e) {
+  console.log(`Estimated tokens: ~${Math.ceil(pathContent.length / 4)}`);
+}