@far-world-labs/verblets 0.1.1

package/src/services/redis/index.js

@@ -0,0 +1,84 @@
+import { createClient } from 'redis';
+
+let client;
+let constructingClient;
+
+class NullRedisClient {
+  constructor() {
+    this.store = {};
+  }
+
+  async get(key) {
+    // Redis returns null, not undefined
+    return this.store[key] ?? null;
+  }
+
+  async del(key) {
+    delete this.store[key];
+  }
+
+  async set(key, value) {
+    this.store[key] = value;
+  }
+
+  // eslint-disable-next-line class-methods-use-this, no-empty-function
+  async disconnect() {
+    // no implementation
+  }
+}
+
+const constructClient = async () => {
+  if (process.env.TEST === 'true' && process.env.EXAMPLES !== 'true') {
+    client = new NullRedisClient();
+    return;
+  }
+
+  const redisClient = createClient({
+    host: process.env.REDIS_HOST ?? 'localhost',
+    port: process.env.REDIS_PORT ?? 6379,
+  });
+
+  redisClient.on('error', (error) => {
+    if (client instanceof NullRedisClient) {
+      return;
+    }
+
+    if (/ECONNREFUSED/.test(error.message)) {
+      console.error(
+        `Redis service [warning]: "${error.message}" Falling back to mock Redis client. This may incur greater usage costs and have slower response times.`
+      );
+      client = new NullRedisClient();
+    } else {
+      console.error(`Redis service [error]: ${error.message}`);
+    }
+
+    redisClient.disconnect();
+  });
+
+  try {
+    await redisClient.connect();
+    client = redisClient;
+  } catch (error) {
+    console.error(
+      `Redis service create [warning]: "${error.message}" Falling back to mock Redis client. This may incur greater usage costs and have slower response times.`
+    );
+    client = new NullRedisClient();
+  }
+};
+
+export const getClient = async () => {
+  if (client) {
+    return client;
+  }
+
+  if (!constructingClient) {
+    constructingClient = constructClient();
+  }
+
+  await constructingClient;
+  return client;
+};
+
+export const setClient = (newClient) => {
+  client = newClient;
+};

package/src/verblets/auto/index.examples.js

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import auto from './index.js';
+
+const examples = [
+  {
+    inputs: { text: 'test' },
+    want: { result: true }
+  }
+];
+
+describe('Auto verblet', () => {
+  examples.forEach((example) => {
+    it(example.inputs.text, async () => {
+      const result = await auto(example.inputs.text)
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+
+      if (example.want.result) {
+        expect(result)
+          .toStrictEqual(example.want.result);
+      }
+    });
+  });
+});

package/src/verblets/auto/index.js

@@ -0,0 +1,28 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import toObject from '../../verblets/to-object/index.js';
+import schemas from '../../json-schemas/index.js'
+
+export default async (text, options={}) => {
+  const tools = schemas
+    .map(schema => ({
+      type: 'function',
+      function: schema
+    }))
+
+  const functionFound = await chatGPT(text, {
+    modelOptions: {
+      // toolChoice: 'auto' // by default
+      tools,
+    },
+    ...options
+  });
+
+  const functionArgs = functionFound.arguments;
+
+  const functionArgsAsArray = Array.isArray(functionArgs) ? functionArgs : [functionArgs];
+
+  return {
+    ...functionFound,
+    functionArgsAsArray
+  };
+};

package/src/verblets/auto/index.spec.js

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import auto from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/prompt text to match/.test(text)) {
+      return 'True';
+    } else {
+      return 'undefined';
+    }
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'test' },
+    want: { result: true }
+  }
+];
+
+describe('Auto verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await auto(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});

package/src/verblets/bool/index.examples.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+
+import bool from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+const examples = [
+  {
+    inputs: { text: 'Does Mace Windu have a blue lightsaber?' },
+    want: { result: false },
+  },
+  {
+    inputs: { text: 'Does Mace Windu have a purple lightsaber?' },
+    want: { result: true },
+  },
+];
+
+describe('Bool verblet', () => {
+  examples.forEach((example) => {
+    it(
+      `${example.inputs.text}`,
+      async () => {
+        const result = await bool(example.inputs.text);
+        expect(result).toStrictEqual(example.want.result);
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/bool/index.js

@@ -0,0 +1,28 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import toBool from '../../lib/to-bool/index.js';
+import { constants as promptConstants } from '../../prompts/index.js';
+
+const {
+  asBool,
+  asUndefinedByDefault,
+  contentIsQuestion,
+  explainAndSeparate,
+  explainAndSeparatePrimitive,
+} = promptConstants;
+
+export default async (text, options={}) => {
+  const systemPrompt = `
+${explainAndSeparate} ${explainAndSeparatePrimitive}
+
+${asBool} ${asUndefinedByDefault}
+`
+  const response = await chatGPT(text, {
+    modelOptions: {
+      systemPrompt,
+    },
+    ...options,
+  });
+
+  return toBool(stripResponse(response));
+};

package/src/verblets/bool/index.schema.json

@@ -0,0 +1,14 @@
+{
+  "name": "bool",
+  "description": "Interpret a question seen as a yes/no question, and return a boolean value answer.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "A question to be answered."
+      }
+    },
+    "required": ["text"]
+  }
+}

package/src/verblets/bool/index.spec.js

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import bool from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/purple lightsaber/.test(text)) {
+      return 'True';
+    }
+    return 'False';
+  }),
+}));
+
+const examples = [
+  {
+    title: 'True values',
+    inputs: { text: 'Does Mace Windu have a purple lightsaber' },
+    want: { result: true },
+  },
+  {
+    title: 'False values',
+    inputs: { text: 'Does Mace Windu have a blue lightsaber' },
+    want: { result: false },
+  },
+];
+
+describe('bool verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      expect(await bool(example.inputs.text)).toStrictEqual(
+        example.want.result
+      );
+    });
+  });
+});

package/src/verblets/enum/index.examples.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import enumValue from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+const examples = [
+  {
+    inputs: {
+      text: 'What is the top color on a traffic light',
+      enum: { green: 1, yellow: 1, red: 1, purple: 1 },
+    },
+    want: { result: 'red' },
+  },
+];
+
+describe('Enum verblet', () => {
+  examples.forEach((example) => {
+    it(
+      example.inputs.text,
+      async () => {
+        const result = await enumValue(
+          example.inputs.text,
+          example.inputs.enum
+        );
+
+        if (example.want.result) {
+          expect(result).toStrictEqual(example.want.result);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/enum/index.js

@@ -0,0 +1,15 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import toEnum from '../../lib/to-enum/index.js';
+import { asEnum, constants } from '../../prompts/index.js';
+
+const { asUndefinedByDefault, contentIsQuestion, explainAndSeparate } =
+  constants;
+
+export default async (text, enumVal) => {
+  const enumText = `${contentIsQuestion} ${text}\n\n${explainAndSeparate}
+
+${asEnum(enumVal)} ${asUndefinedByDefault}`;
+
+  return toEnum(stripResponse(await chatGPT(enumText)), enumVal);
+};

package/src/verblets/enum/index.spec.js

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import enumValue from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/traffic light/.test(text)) {
+      return 'red';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: {
+      text: 'What is the top color on a traffic light',
+      enum: { green: 1, yellow: 1, red: 1, purple: 1 },
+    },
+    want: { result: 'red' },
+  },
+];
+
+describe('Enum verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await enumValue(example.inputs.text, example.inputs.enum);
+
+      if (example.want.result) {
+        expect(result).toStrictEqual(example.want.result);
+      }
+    });
+  });
+});

package/src/verblets/intent/index.examples.js

@@ -0,0 +1,51 @@
+import Ajv from 'ajv';
+import fs from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+
+import { longTestTimeout } from '../../constants/common.js';
+import intent from './index.js';
+
+const resultSchema = async () => {
+  return JSON.parse(await fs.readFile('./src/json-schemas/intent.json'));
+};
+
+const examples = [
+  {
+    inputs: { text: 'Give me a flight to Burgas' },
+    want: { resultSchema },
+  },
+  {
+    inputs: {
+      text: 'Lookup a song by the quote \
+"I just gotta tell you how I\'m feeling"',
+    },
+    want: { resultSchema },
+  },
+];
+
+describe('Intent verblet', () => {
+  examples.forEach((example) => {
+    it(
+      example.inputs.text,
+      async () => {
+        const result = await intent({ text: example.inputs.text });
+
+        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(validate.errors);
+            console.error('Returned result:');
+            console.error(JSON.stringify(result, null, 2));
+          }
+          expect(isValid).toStrictEqual(true);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/intent/index.js

@@ -0,0 +1,72 @@
+import enums from '../enum/index.js';
+import toObject from '../to-object/index.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+
+import { constants, intent, wrapVariable } from '../../prompts/index.js';
+
+const { contentHasIntent } = constants;
+const example1 =
+  'The intent of "Buy me a flight to Burgas" might be "buy-flight"';
+const example2 =
+  'The intent of "What is the tempature outside" might be "get-temperature"';
+
+const enumPrompt = (text) => `${contentHasIntent} ${wrapVariable(text, {
+  tag: 'message',
+})}
+
+${wrapVariable(example1, { tag: 'example' })}
+${wrapVariable(example2, { tag: 'example' })}`;
+
+const completionIntent = (text) => ({
+  queryText: text,
+  intent: {
+    operation: 'completion',
+    displayName: 'Completion',
+  },
+  parameters: {
+    text,
+  },
+});
+
+export default async ({
+  text,
+  operations,
+  defaultIntent = completionIntent,
+  options,
+} = {}) => {
+  let operationsFound;
+  let parametersFound;
+  if (operations) {
+    const operationsEnum = operations.reduce(
+      (acc, item, idx) => ({
+        ...acc,
+        [item.name]: idx,
+      }),
+      {}
+    );
+
+    const operationNameFound = await enums(enumPrompt(text), operationsEnum);
+
+    const operationFound = operations.find(
+      (o) => o.name === operationNameFound
+    );
+
+    if (!operationFound) {
+      return defaultIntent(text);
+    }
+
+    operationsFound = [operationFound.name];
+    parametersFound = operationFound.parameters;
+  }
+
+  const result = await chatGPT(
+    intent(text, {
+      operations: operationsFound,
+      parameters: parametersFound,
+    }),
+    options
+  );
+
+  return toObject(stripResponse(result));
+};

package/src/verblets/intent/index.spec.js

@@ -0,0 +1,31 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import intent from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/a flight to/.test(text)) {
+      return '{}';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'Give me a flight to Burgas' },
+    want: { typeOfResult: 'object' },
+  },
+];
+
+describe('Intent verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await intent({ text: example.inputs.text });
+      if (example.want.typeOfResult) {
+        expect(typeof result).toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});

package/src/verblets/number/index.examples.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import number from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+const examples = [
+  {
+    inputs: { text: 'What is the height of Everest in feet' },
+    want: { result: 29029 },
+  },
+  {
+    inputs: { text: 'What is the length of the Nile in km' },
+    want: { result: 6650 },
+  },
+  {
+    inputs: { text: 'What is the my age in years' },
+    want: { result: undefined },
+  },
+];
+
+describe('Number verblet', () => {
+  examples.forEach((example) => {
+    it(
+      example.inputs.text,
+      async () => {
+        expect(await number(example.inputs.text)).toStrictEqual(
+          example.want.result
+        );
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/verblets/number/index.js

@@ -0,0 +1,22 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import toNumber from '../../lib/to-number/index.js';
+import { constants as promptConstants } from '../../prompts/index.js';
+
+const {
+  asNumber,
+  asUndefinedByDefault,
+  contentIsQuestion,
+  explainAndSeparate,
+  explainAndSeparatePrimitive,
+} = promptConstants;
+
+export default async (text) => {
+  const numberText = `${contentIsQuestion} ${text}
+
+${explainAndSeparate} ${explainAndSeparatePrimitive}
+
+${asNumber} ${asUndefinedByDefault}`;
+
+  return toNumber(stripResponse(await chatGPT(numberText)));
+};

package/src/verblets/number/index.spec.js

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

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

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import numberWithUnits from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+const examples = [
+  {
+    inputs: { text: 'What is the height of Everest in feet' },
+    want: { value: 29029, unit: 'feet' },
+  },
+  {
+    inputs: { text: 'What is my age in years' },
+    want: { value: undefined, unit: 'years' },
+  },
+];
+
+describe('Number with units verblet', () => {
+  examples.forEach((example) => {
+    it(
+      example.inputs.text,
+      async () => {
+        const result = await numberWithUnits(example.inputs.text);
+
+        if (example.want.value) {
+          expect(result?.value).toStrictEqual(example.want.value);
+        }
+        if (example.want.unit) {
+          expect(result?.unit).toStrictEqual(example.want.unit);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

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

@@ -0,0 +1,19 @@
+import chatGPT from '../../lib/chatgpt/index.js';
+import stripResponse from '../../lib/strip-response/index.js';
+import toNumberWithUnits from '../../lib/to-number-with-units/index.js';
+import { constants as promptConstants } from '../../prompts/index.js';
+
+const {
+  asNumberWithUnits,
+  contentIsQuestion,
+  explainAndSeparate,
+  explainAndSeparateJSON,
+} = promptConstants;
+
+export default async (text) => {
+  const numberText = `${contentIsQuestion} ${text} \n\n${explainAndSeparate} ${explainAndSeparateJSON}
+
+${asNumberWithUnits}`;
+
+  return toNumberWithUnits(stripResponse(await chatGPT(numberText)));
+};