@far-world-labs/verblets 0.1.1

package/src/verblets/number-with-units/index.spec.js

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import numberWithUnits from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/Everest/.test(text)) {
+      return '{ "value": 29029, "unit": "feet" }';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'What is the height of Everest in feet' },
+    want: { value: 29029, unit: 'feet' },
+  },
+  {
+    name: 'Unanswerable question',
+    inputs: { text: 'What is my age in years' },
+    want: { typeOfValue: 'undefined', typeOfUnit: 'undefined' },
+  },
+];
+
+describe('Number with units verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await numberWithUnits(example.inputs.text);
+      if (example.want.value) {
+        expect(result?.value).toStrictEqual(example.want.value);
+      }
+      if (example.want.typeOfValue) {
+        expect(typeof result?.value).toStrictEqual(example.want.typeOfValue);
+      }
+
+      if (example.want.unit) {
+        expect(result?.unit).toStrictEqual(example.want.unit);
+      }
+      if (example.want.typeOfValue) {
+        expect(typeof result?.value).toStrictEqual(example.want.typeOfValue);
+      }
+    });
+  });
+});

package/src/verblets/schema-org/index.examples.js

@@ -0,0 +1,56 @@
+import Ajv from 'ajv';
+import fs from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+
+import { longTestTimeout } from '../../constants/common.js';
+import schemaOrg from './index.js';
+
+const resultSchemaWith = (type) => async () => {
+  return JSON.parse(
+    await fs.readFile(
+      `./src/json-schemas/schema-dot-org-${type.toLowerCase()}.json`
+    )
+  );
+};
+
+const examples = [
+  {
+    inputs: { text: 'Kyoto (location)' },
+    want: { resultSchema: resultSchemaWith('Place') },
+  },
+  {
+    inputs: { text: 'Kyoto (location)', type: 'Photograph' },
+    want: { resultSchema: resultSchemaWith('Photograph') },
+  },
+];
+
+describe('Schema.org verblet', () => {
+  examples.forEach((example) => {
+    const typeDisplay = example.inputs.type ? ` - ${example.inputs.type}` : '';
+    it(
+      `${example.inputs.text}${typeDisplay}`,
+      async () => {
+        const result = await schemaOrg(
+          example.inputs.text,
+          example.inputs.type
+        );
+
+        if (example.want.resultSchema) {
+          const schema = await example.want.resultSchema();
+          const ajv = new Ajv();
+          const validate = ajv.compile(schema);
+
+          const isValid = validate(result);
+          if (!isValid) {
+            console.error('Validation errors:');
+            console.error(JSON.stringify(validate.errors, null, 2));
+            console.error('Returned result:');
+            console.error(JSON.stringify(result, null, 2));
+          }
+          expect(isValid).toStrictEqual(true);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/schema-org/index.js

@@ -0,0 +1,8 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import { asSchemaOrgText } from '../../prompts/index.js';
+import toObject from '../to-object/index.js';
+
+export default async (text, type) => {
+  return toObject(stripResponse(await chatGPT(asSchemaOrgText(text, type))));
+};

package/src/verblets/schema-org/index.spec.js

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import schemaOrg from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/Kyoto \(location\)/.test(text)) {
+      // Nothing is done with the result
+      // so returning something complicated only introduces complexity
+      return '{}';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'Kyoto (location)' },
+    want: { typeOfResult: 'object' },
+  },
+  {
+    name: 'Basic usage',
+    inputs: { text: 'Kyoto (location)', type: 'Photo' },
+    want: { typeOfResult: 'object' },
+  },
+];
+
+describe('Schema.org verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await schemaOrg(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(typeof result).toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});

package/src/verblets/to-object/README.md

@@ -0,0 +1,38 @@
+# to-object - JSON repair and validation
+
+This module is designed to take JSON results from ChatGPT calls, which can often be imperfect or malformed, and repair them to create valid JSON. If a JSON Schema is provided, the module also validates the repaired JSON against it. This process ensures that the JSON data is both well-formed and conforms to the expected structure.
+
+## Features
+
+- Automatic repair of malformed JSON data returned by ChatGPT.
+- Validation of repaired JSON data against provided JSON Schemas using the [Ajv](https://ajv.js.org/) library.
+- Recursive repair attempts through internal calls to ChatGPT for particularly stubborn cases.
+- Detailed error handling and validation messages
+- Custom ValidationError class for understanding where the returned JSON fails to meet the schema.
+
+## Installation
+
+This module is part of a larger project and is not designed to be installed standalone. However, you can copy the module into your own project and install the necessary dependencies via npm or yarn:
+
+```bash
+npm install ajv
+```
+
+## Usage
+
+The primary function exported by this module takes two arguments: a text string to be parsed into JSON, and an optional schema object which describes the expected format of the JSON data.
+
+Here is an example of how to use the module:
+```javascript
+import toObject from './path/to/module';
+
+const text = '...';  // JSON string returned from a ChatGPT call
+const schema = { ... };  // Optional JSON Schema
+
+try {
+  const result = await toObject(text, schema);
+  console.error(result);  // Repaired and validated JSON
+} catch (error) {
+  console.error(error);  // Validation message if JSON doesn't meet the schema
+}
+```

package/src/verblets/to-object/index.examples.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import toObject from './index.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+const examples = [
+  {
+    inputs: { text: 'Describe SpaceX Starship' },
+    want: { typeOfResult: 'object' },
+  },
+];
+
+describe('To object verblet', () => {
+  examples.forEach((example) => {
+    it(
+      example.inputs.text,
+      async () => {
+        const chatGPTResult = await chatGPT(example.inputs.text);
+        const result = await toObject(chatGPTResult);
+
+        if (example.want.typeOfResult) {
+          expect(typeof result).toStrictEqual(example.want.typeOfResult);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/to-object/index.js

@@ -0,0 +1,136 @@
+import Ajv from 'ajv';
+
+import { debugToObject } from '../../constants/common.js';
+import { retryJSONParse } from '../../constants/messages.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import {
+  constants as promptConstants,
+  wrapVariable,
+} from '../../prompts/index.js';
+
+const { contentIsSchema, contentToJSON, onlyJSON, shapeAsJSON } =
+  promptConstants;
+
+class ValidationError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = 'ValidationError';
+    this.details = details;
+  }
+}
+
+function buildJsonPrompt(text, schema, errors) {
+  let errorsDisplay = '';
+  if (errors?.length) {
+    errorsDisplay = wrapVariable(JSON.stringify(errors) ?? '', {
+      tag: 'json-schema-errors--do-not-output',
+    });
+  }
+
+  let schemaPart = '';
+  if (schema) {
+    schemaPart = `${contentIsSchema} ${wrapVariable(JSON.stringify(schema), {
+      tag: 'json-schema--do-not-output',
+    })}`;
+  }
+
+  return `${onlyJSON} ${shapeAsJSON}
+
+${schemaPart}
+
+${errorsDisplay}
+
+${contentToJSON} ${wrapVariable(stripResponse(text), { tag: 'content' })}
+
+${onlyJSON}`;
+}
+
+export default async (text, schema) => {
+  let prompt;
+  let result;
+  let response = text;
+  let errorDetails;
+
+  try {
+    result = JSON.parse(stripResponse(response));
+    if (schema) {
+      const ajv = new Ajv();
+      const validate = ajv.compile(schema);
+      const isValid = validate(result);
+
+      if (!isValid) {
+        throw new ValidationError('Ajv validation failed', validate.errors);
+      }
+      return result;
+    }
+    return result;
+  } catch (error) {
+    errorDetails = error.details;
+    if (debugToObject) {
+      console.error(`Parse JSON [error]: ${error.message} ${retryJSONParse}`);
+      console.error('<prompt attempt=1 value="unknown" />');
+      console.error('<response>');
+      console.error(stripResponse(response));
+      console.error('</response>');
+      console.error('<error>');
+      console.error(error);
+      console.error('</error>');
+    }
+  }
+
+  try {
+    prompt = buildJsonPrompt(response, schema, errorDetails);
+    response = await chatGPT(prompt, {
+      modelOptions: {
+        modelName: 'gpt35Turbo',
+      },
+    });
+    result = JSON.parse(stripResponse(response));
+
+    if (schema) {
+      const ajv = new Ajv();
+      const validate = ajv.compile(schema);
+      const isValid = validate(result);
+
+      if (!isValid) {
+        throw new ValidationError('Ajv validation failed', validate.errors);
+      }
+      return result;
+    }
+  } catch (error) {
+    errorDetails = error.details;
+    if (debugToObject) {
+      console.error(`Parse JSON [error]: ${error.message} ${retryJSONParse}`);
+      console.error('<prompt attempt=2>');
+      console.error(prompt);
+      console.error('</prompt>');
+      console.error('<response>');
+      console.error(stripResponse(response));
+      console.error('</response>');
+      console.error('<error>');
+      console.error(error);
+      console.error('</error>');
+    }
+
+    prompt = buildJsonPrompt(response, schema, errorDetails);
+    response = await chatGPT(prompt, {
+      modelOptions: {
+        modelName: 'gpt35Turbo',
+      },
+    });
+    result = JSON.parse(stripResponse(response));
+
+    if (debugToObject) {
+      console.error(`Parse JSON [error]: ${error.message} ${retryJSONParse}`);
+      console.error('<prompt attempt=3>');
+      console.error(prompt);
+      console.error('</prompt>');
+      console.error('<response>');
+      console.error(stripResponse(response));
+      console.error('</response>');
+    }
+  }
+
+  return result;
+};

package/src/verblets/to-object/index.spec.js

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import toObject from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/test/.test(text)) {
+      return '{}';
+    }
+    if (/valid-schema/.test(text)) {
+      return '{"key": "value"}';
+    }
+    if (/invalid-schema/.test(text)) {
+      return '{"key": "value", "extra": "unexpected"}';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'test' },
+    want: { typeOfResult: 'object' },
+  },
+  {
+    name: 'Valid schema',
+    inputs: {
+      text: 'valid-schema',
+      schema: {
+        type: 'object',
+        properties: { key: { type: 'string' } },
+        required: ['key'],
+      },
+    },
+    want: { typeOfResult: 'object' },
+  },
+  {
+    name: 'Invalid schema',
+    inputs: {
+      text: 'invalid-schema',
+      schema: {
+        type: 'object',
+        properties: { key: { type: 'string' } },
+        additionalProperties: false,
+        required: ['key'],
+      },
+    },
+    wantError: true,
+  },
+];
+
+describe('To object verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      try {
+        const result = await toObject(
+          example.inputs.text,
+          example.inputs.schema
+        );
+
+        if (example.want.typeOfResult) {
+          expect(typeof result).toStrictEqual(example.want.typeOfResult);
+        }
+      } catch (error) {
+        if (example.wantError) {
+          expect(error).toBeInstanceOf(Error);
+        } else {
+          throw error;
+        }
+      }
+    });
+  });
+});