@solvers-hub/llm-json 0.1.5 → 0.1.7

package/examples/array-example.ts

@@ -0,0 +1,69 @@
+import LlmJson from '../src/index';
+
+/**
+ * Example demonstrating how to use the LLM-JSON library for arrays.
+ */
+function runArrayExample() {
+    // Create an instance with auto-correction enabled
+    const llmJson = new LlmJson({ attemptCorrection: true });
+
+    // Simple array example
+    const simpleArrayInput = `Here is a list of names: ["John", "Jane", "Bob"]`;
+
+    console.log("=== Simple Array Example ===");
+
+    // Using extract - might not properly handle standalone arrays
+    const simpleExtractResult = llmJson.extract(simpleArrayInput);
+    console.log("With extract():");
+    console.log("Text:", simpleExtractResult.text);
+    console.log("JSON:", JSON.stringify(simpleExtractResult.json, null, 2));
+    console.log();
+
+    // Using extractAll - properly handles arrays
+    const simpleExtractAllResult = llmJson.extractAll(simpleArrayInput);
+    console.log("With extractAll():");
+    console.log("Text:", simpleExtractAllResult.text);
+    console.log("JSON:", JSON.stringify(simpleExtractAllResult.json, null, 2));
+    console.log();
+
+    // Complex array example
+    const complexArrayInput = `Here's an array of users:
+  [
+    {
+      "name": "John Doe",
+      "age": 30,
+      "skills": ["JavaScript", "TypeScript"]
+    },
+    {
+      "name": "Jane Smith",
+      "age": 28,
+      "skills": ["Python", "Machine Learning"]
+    }
+  ]`;
+
+    console.log("=== Complex Array Example ===");
+
+    // Using extractAll - properly handles complex arrays
+    const complexResult = llmJson.extractAll(complexArrayInput);
+    console.log("With extractAll():");
+    console.log("Text:", complexResult.text);
+    console.log("JSON:", JSON.stringify(complexResult.json, null, 2));
+    console.log();
+
+    // Multiple JSON structures example
+    const mixedInput = `Here's an object: {"name": "John", "age": 30}
+  
+  And here's an array: [1, 2, 3, 4, 5]
+  
+  And another object: {"city": "New York", "country": "USA"}`;
+
+    console.log("=== Mixed JSON Types Example ===");
+
+    // Using extractAll - handles both objects and arrays
+    const mixedResult = llmJson.extractAll(mixedInput);
+    console.log("With extractAll():");
+    console.log("Text:", mixedResult.text);
+    console.log("JSON:", JSON.stringify(mixedResult.json, null, 2));
+}
+
+runArrayExample(); 

package/examples/example.ts

@@ -0,0 +1,101 @@
+import LlmJson from '../src/index';
+
+/**
+ * Example demonstrating how to use the LLM-JSON library.
+ */
+function runExample() {
+  // Create an instance with auto-correction enabled
+  const llmJson = new LlmJson({ attemptCorrection: true });
+
+  // Example from the requirements
+  const input = `<research_planning>
+a. Summary: The given organization is unnamed and works in the area of "something new," which suggests an innovative or emerging field. This could involve novel technologies, fresh market approaches, or unexplored domains. Without specific details, assumptions about the sector or industry may involve startups, tech innovation, or trendsetting industries. The focus and goals may lean toward exploration, user adoption, and refinement of novel concepts.
+
+b. Potential Product Features: 
+   - Exploration of new technologies (VR/AR interfaces, IoT integration)
+   - User onboarding and education tools 
+   - Novel interaction models or user interfaces
+   - Feedback and improvement loops
+   - Community engagement and collaboration spaces
+
+c. User Persona: Considering the organization's innovative nature, the primary user could be an early adopter, tech-savvy individual who is curious and willing to explore new technologies. This persona is likely someone who enjoys experimenting with novel ideas and is motivated by the excitement of participating in pioneering efforts. 
+   Study Name: "Demo - Innovator Insight"
+
+d. Potential Research Objectives:
+   - Evaluate user onboarding process effectiveness in helping users understand the product's novel features.
+   - Assess user engagement with community collaboration spaces to identify areas for increased interaction.
+   - Verify the intuitiveness of new interaction models and user interfaces.
+   - Explore user satisfaction with feedback and improvement loops.
+   - Measure the impact of educational tools on user empowerment and confidence.
+   - Analyze user behavior patterns to refine product workflows.
+   - Investigate potential barriers to user adoption and retention.
+   
+e. Narrowing Down Objectives: 
+   After considering the potential research objectives, the focus shifted towards objectives that can be directly evaluated through a live web application. The final objectives chosen were geared towards user onboarding, interaction intuitiveness, and community engagement, as they align with the persona of an early adopter and focus on improving user experience in areas relevant to the organization's innovative nature.
+</research_planning>
+
+\`\`\`json
+{
+  "studyName": "Demo - Innovator Insight",
+  "userPersona": "Tech-savvy early adopter exploring new innovations.",
+  "objectives": [
+    {
+      "objectiveTitle": "Onboarding Process Evaluation",
+      "objectiveDescription": "Assess the effectiveness of the user onboarding process in enabling users to grasp the novel features of the product quickly and efficiently, ensuring that it enhances initial user engagement and reduces learning curves."
+    },
+    {
+      "objectiveTitle": "Community Interaction Analysis",
+      "objectiveDescription": "Investigate user engagement within community collaboration spaces, identifying potential improvements to foster more interaction, sharing, and collaboration among users, enhancing overall community dynamics."
+    },
+    {
+      "objectiveTitle": "Interface Intuition Verification",
+      "objectiveDescription": "Verify the intuitiveness of new interaction models and user interfaces, focusing on how users adapt and navigate through the product, aiming to identify any areas needing refinement for better usability."
+    }
+  ]
+}
+\`\`\``;
+
+  // Extract JSON and text
+  const result = llmJson.extract(input);
+
+  console.log("Extracted text:");
+  console.log("------------------");
+  result.text.forEach((text, index) => {
+    console.log(`Text block ${index + 1}:`);
+    console.log(text);
+    console.log();
+  });
+
+  console.log("Extracted JSON:");
+  console.log("------------------");
+  result.json.forEach((json, index) => {
+    console.log(`JSON object ${index + 1}:`);
+    console.log(JSON.stringify(json, null, 2));
+    console.log();
+  });
+
+  // Example with malformed JSON
+  console.log("\nExample with malformed JSON:");
+  console.log("---------------------------");
+
+  const malformedInput = `Here is some information:
+  
+  {
+    name: "John",
+    age: 30,
+    skills: ["JavaScript", "TypeScript"],
+    preferences: {
+      theme: "dark",
+      notifications: true,
+    }
+  }`;
+
+  const malformedResult = llmJson.extract(malformedInput);
+
+  console.log("Text:");
+  console.log(malformedResult.text[0]);
+  console.log("\nCorrected JSON:");
+  console.log(JSON.stringify(malformedResult.json[0], null, 2));
+}
+
+runExample();

package/examples/schema-validation-example.ts

@@ -0,0 +1,140 @@
+import LlmJson from '../src/index';
+
+/**
+ * Example demonstrating how to use schema validation with the LLM-JSON library.
+ */
+function runSchemaValidationExample() {
+  console.log('Schema Validation Example');
+  console.log('=========================\n');
+
+  // Define some schemas for validation
+  const schemas = [
+    {
+      name: 'person',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer' },
+          email: { type: 'string' }
+        },
+        required: ['name', 'age']
+      }
+    },
+    {
+      name: 'product',
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          name: { type: 'string' },
+          price: { type: 'number' }
+        },
+        required: ['id', 'name', 'price']
+      }
+    }
+  ];
+
+  // Create an instance with auto-correction and schemas
+  const llmJson = new LlmJson({
+    attemptCorrection: true,
+    schemas
+  });
+
+  // Example 1: Valid JSON matching a schema
+  console.log('Example 1: Valid JSON matching a schema');
+  console.log('----------------------------------------');
+
+  const input1 = `Here's some customer information:
+  
+  {
+    "name": "John Doe",
+    "age": 32,
+    "email": "john.doe@example.com"
+  }
+  
+  Please process this customer data.`;
+
+  const result1 = llmJson.extract(input1);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result1.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result1.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 2: Valid JSON but doesn't match any schema
+  console.log('Example 2: Valid JSON but doesn\'t match any schema');
+  console.log('--------------------------------------------------');
+
+  const input2 = `Here's some location data:
+  
+  {
+    "latitude": 37.7749,
+    "longitude": -122.4194,
+    "city": "San Francisco"
+  }`;
+
+  const result2 = llmJson.extract(input2);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result2.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result2.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 3: Multiple JSON objects with some matching schemas
+  console.log('Example 3: Multiple JSON objects with some matching schemas');
+  console.log('--------------------------------------------------------');
+
+  const input3 = `Here are two different objects:
+  
+  First, a person:
+  {
+    "name": "Jane Smith",
+    "age": 28
+  }
+  
+  And a product:
+  {
+    "id": "prod-123",
+    "name": "Laptop",
+    "price": 999.99
+  }
+  
+  And something that doesn't match our schemas:
+  {
+    "title": "Meeting Notes",
+    "date": "2023-05-15"
+  }`;
+
+  const result3 = llmJson.extract(input3);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result3.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result3.validatedJson, null, 2));
+  console.log('\n');
+
+  // Example 4: Malformed JSON that gets corrected and validated
+  console.log('Example 4: Malformed JSON that gets corrected and validated');
+  console.log('----------------------------------------------------------');
+
+  const input4 = `This JSON has errors but should be fixed:
+  
+  {
+    name: "Alex Johnson",
+    age: 42,
+    email: "alex@example.com"
+  }`;
+
+  const result4 = llmJson.extract(input4);
+
+  console.log('Extracted JSON:');
+  console.log(JSON.stringify(result4.json, null, 2));
+  console.log('\nValidation Results:');
+  console.log(JSON.stringify(result4.validatedJson, null, 2));
+}
+
+// Run the example
+runSchemaValidationExample(); 

package/examples/schema-validation-examples.ts

@@ -0,0 +1,248 @@
+import LlmJson from '../src/index';
+
+/**
+ * Comprehensive examples of schema validation with LLM-JSON
+ */
+function runSchemaValidationExamples() {
+    // Example 1: Basic schema with required and optional fields
+    
+    const input1 = `Here's a user profile:
+    {
+        "name": "John Doe",
+        "age": 30,
+        "email": "john@example.com",
+        "location": "New York"
+    }`;
+
+    const userSchema = {
+        name: 'user',
+        schema: {
+            type: 'object',
+            required: ['name', 'email'],  // These fields must be present
+            properties: {
+                name: { type: 'string' },
+                email: { type: 'string', format: 'email' },
+                age: { type: 'number' },  // Optional field
+                location: { type: 'string' }  // Optional field
+            }
+        }
+    };
+
+    // Example 2: Complex schema with nested objects and arrays
+
+    const input2 = `Here's a product catalog:
+    {
+        "product": {
+            "id": "123",
+            "name": "Smartphone",
+            "price": 599.99,
+            "specifications": {
+                "brand": "TechCo",
+                "model": "X100",
+                "features": ["5G", "Wireless Charging", "Dual Camera"]
+            },
+            "inventory": {
+                "inStock": true,
+                "quantity": 50,
+                "locations": [
+                    {
+                        "store": "Main Store",
+                        "quantity": 30
+                    },
+                    {
+                        "store": "Branch Store",
+                        "quantity": 20
+                    }
+                ]
+            }
+        }
+    }`;
+
+    const productSchema = {
+        name: 'product',
+        schema: {
+            type: 'object',
+            required: ['product'],
+            properties: {
+                product: {
+                    type: 'object',
+                    required: ['id', 'name', 'price', 'specifications', 'inventory'],
+                    properties: {
+                        id: { type: 'string' },
+                        name: { type: 'string' },
+                        price: { type: 'number', minimum: 0 },
+                        specifications: {
+                            type: 'object',
+                            required: ['brand', 'model', 'features'],
+                            properties: {
+                                brand: { type: 'string' },
+                                model: { type: 'string' },
+                                features: {
+                                    type: 'array',
+                                    items: { type: 'string' }
+                                }
+                            }
+                        },
+                        inventory: {
+                            type: 'object',
+                            required: ['inStock', 'quantity', 'locations'],
+                            properties: {
+                                inStock: { type: 'boolean' },
+                                quantity: { type: 'integer', minimum: 0 },
+                                locations: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        required: ['store', 'quantity'],
+                                        properties: {
+                                            store: { type: 'string' },
+                                            quantity: { type: 'integer', minimum: 0 }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    // Example 3: Multiple schemas for different types of data
+
+    const input3 = `Here are different types of records:
+    {
+        "employee": {
+            "id": "E123",
+            "name": "Jane Smith",
+            "department": "Engineering",
+            "skills": ["JavaScript", "TypeScript", "React"],
+            "contact": {
+                "email": "jane@company.com",
+                "phone": "+1-234-567-8900"
+            }
+        }
+    }
+
+    {
+        "project": {
+            "id": "P789",
+            "name": "Website Redesign",
+            "status": "in-progress",
+            "deadline": "2024-12-31",
+            "teamSize": 5,
+            "budget": 50000
+        }
+    }`;
+
+    const employeeSchema = {
+        name: 'employee',
+        schema: {
+            type: 'object',
+            required: ['employee'],
+            properties: {
+                employee: {
+                    type: 'object',
+                    required: ['id', 'name', 'department', 'skills', 'contact'],
+                    properties: {
+                        id: { type: 'string', pattern: '^E\\d+$' },  // Must start with E followed by numbers
+                        name: { type: 'string' },
+                        department: { type: 'string' },
+                        skills: { 
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 1  // Must have at least one skill
+                        },
+                        contact: {
+                            type: 'object',
+                            required: ['email'],
+                            properties: {
+                                email: { type: 'string', format: 'email' },
+                                phone: { type: 'string' }  // Optional
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    const projectSchema = {
+        name: 'project',
+        schema: {
+            type: 'object',
+            required: ['project'],
+            properties: {
+                project: {
+                    type: 'object',
+                    required: ['id', 'name', 'status', 'deadline', 'teamSize'],
+                    properties: {
+                        id: { type: 'string', pattern: '^P\\d+$' },  // Must start with P followed by numbers
+                        name: { type: 'string' },
+                        status: { 
+                            type: 'string',
+                            enum: ['not-started', 'in-progress', 'completed']  // Only these values allowed
+                        },
+                        deadline: { 
+                            type: 'string',
+                            format: 'date'  // Must be a valid date string
+                        },
+                        teamSize: { 
+                            type: 'integer',
+                            minimum: 1,
+                            maximum: 20  // Team size constraints
+                        },
+                        budget: {
+                            type: 'number',
+                            minimum: 0  // Optional but must be positive
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    // Create LlmJson instances with different schema combinations
+    const llmJson1 = new LlmJson({ attemptCorrection: true, schemas: [userSchema] });
+    const llmJson2 = new LlmJson({ attemptCorrection: true, schemas: [productSchema] });
+    const llmJson3 = new LlmJson({ attemptCorrection: true, schemas: [employeeSchema, projectSchema] });
+
+    // Run the examples
+    const result1 = llmJson1.extract(input1);
+    console.log('User Schema Validation Result:');
+    result1.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result1.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result1.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+
+    const result2 = llmJson2.extract(input2);
+    console.log('\nProduct Schema Validation Result:');
+    result2.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result2.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result2.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+
+    const result3 = llmJson3.extract(input3);
+    console.log('\nMultiple Schemas Validation Result:');
+    result3.json.forEach((json, i) => {
+        console.log(`JSON block ${i + 1}:`);
+        console.log(JSON.stringify(json, null, 2));
+        if (result3.validatedJson) {
+            console.log('Validation:');
+            console.log(JSON.stringify(result3.validatedJson[i], null, 2));
+        }
+        console.log();
+    });
+}
+
+runSchemaValidationExamples();

package/package.json

@@ -1,49 +1,53 @@
-{
-    "name": "@solvers-hub/llm-json",
-    "version": "0.1.5",
-    "description": "A TypeScript SDK to extract and correct JSON from LLM outputs",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "author": "Solvers Hub",
-    "license": "MIT",
-    "scripts": {
-        "build": "tsc",
-        "test": "jest",
-        "test:coverage": "jest --coverage",
-        "lint": "eslint src/**/*.ts",
-        "prepublishOnly": "npm run build && npm run docs",
-        "example": "ts-node examples/example.ts",
-        "build:example": "tsc && node dist/examples/example.js",
-        "docs": "typedoc --out docs src",
-        "docs:md": "typedoc --out docs-md --plugin typedoc-plugin-markdown src"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/solvers-hub/llm-json.git"
-    },
-    "bugs": {
-        "url": "https://github.com/solvers-hub/llm-json/issues"
-    },
-    "homepage": "https://github.com/solvers-hub/llm-json#readme",
-    "keywords": [
-        "llm",
-        "json",
-        "extractor",
-        "parser"
-    ],
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
-        "jest": "^29.5.0",
-        "ts-jest": "^29.1.0",
-        "ts-node": "^10.9.1",
-        "typedoc": "^0.25.12",
-        "typedoc-plugin-markdown": "^3.17.1",
-        "typescript": "^5.0.4"
-    },
-    "files": [
-        "dist/**/*",
-        "docs/**/*",
-        "docs-md/**/*"
-    ]
+{
+    "name": "@solvers-hub/llm-json",
+    "version": "0.1.7",
+    "description": "A TypeScript SDK to extract and correct JSON from LLM outputs",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "Solvers Hub",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "test:coverage": "jest --coverage",
+        "lint": "eslint src/**/*.ts",
+        "prepublishOnly": "npm run build && npm run docs",
+        "example:run": "ts-node",
+        "docs": "typedoc --out docs src",
+        "docs:md": "typedoc --out docs-md --plugin typedoc-plugin-markdown src"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/solvers-hub/llm-json.git"
+    },
+    "bugs": {
+        "url": "https://github.com/solvers-hub/llm-json/issues"
+    },
+    "homepage": "https://github.com/solvers-hub/llm-json#readme",
+    "keywords": [
+        "llm",
+        "json",
+        "extractor",
+        "parser"
+    ],
+    "devDependencies": {
+        "@types/jest": "^29.5.0",
+        "@types/node": "^18.15.11",
+        "jest": "^29.5.0",
+        "ts-jest": "^29.1.0",
+        "ts-node": "^10.9.1",
+        "typedoc": "^0.25.12",
+        "typedoc-plugin-markdown": "^3.17.1",
+        "typescript": "^5.0.4"
+    },
+    "dependencies": {
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1"
+    },
+    "files": [
+        "dist/**/*",
+        "docs/**/*",
+        "docs-md/**/*",
+        "examples/**/*"
+    ]
 }