@far-world-labs/verblets 0.1.1

package/src/chains/summary-map/index.examples.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+
+import SummaryMap from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+import pave from '../../lib/pave/index.js';
+
+const legalText = `Pursuant to the stipulations delineated herein, the parties hereto, designated as Party A (the "Grantor") and Party B (the "Grantee"), do hereby irrevocably and unconditionally covenant to abide by the complex and intricate provisions associated with the lesser-known subject matter of usufructuary rights in the realm of riparian watercourses, specifically encompassing the doctrine of correlative rights and the principle of reasonable use, in accordance with the heretofore undisclosed specifications set forth in Schedule U-1.
+
+In pursuance of the aforesaid stipulations, the Grantee shall obtain a non-exclusive, non-transferable, revocable license, subject to the limitations and conditions imposed by the pertinent jurisdictional authorities, to make equitable utilization of the watercourse, taking into account the natural flow, hydrological cycle, and ecological balance, while ensuring the avoidance of significant harm to other riparians by employing the best practicable means in conformity with the established standards of reasonableness, as delineated in the annexed Exhibit R-1, which sets forth the methodology for the determination of the equitable apportionment of said watercourse, and the allocation of the respective usufructuary rights.`;
+
+const codeText = `
+function _generateKey(seed, length) {
+  let key = '';
+  let curr = seed;
+  for (let i = 0; i < length; i++) {
+    curr = (1664525 * curr + 1013904223) % 4294967296;
+    key += String.fromCharCode(curr % 256);
+  }
+  return key;
+}
+
+function _xorStrings(a, b) {
+  let res = '';
+  for (let i = 0; i < a.length; i++) {
+    res += String.fromCharCode(a.charCodeAt(i) ^ b.charCodeAt(i));
+  }
+  return res;
+}
+
+function encodeDecode(input, seed) {
+  let key = _generateKey(seed, input.length);
+  return _xorStrings(input, key);
+}
+`;
+
+describe('Summary map', () => {
+  it(
+    'Example',
+    async () => {
+      const map = new SummaryMap({ targetTokens: 600 });
+
+      map.set('a.b.c', { value: legalText, weight: 0.01 });
+      map.set('a.d', { value: codeText, type: 'code', weight: 0.7 });
+      map.set('e.0', { value: 'abc', weight: 0.01 });
+      map.set('e.3', {
+        value: 'The quick brown fox jump over the lazy dog',
+        weight: 0.7,
+      });
+
+      const entries = Array.from(await map.entries());
+      const result = entries.reduce((acc, [k, v]) => pave(acc, k, v), {});
+
+      expect(result).toBe(result);
+    },
+    longTestTimeout
+  );
+});

package/src/chains/summary-map/index.js

@@ -0,0 +1,208 @@
+/* eslint-disable no-await-in-loop */
+
+import chatGPT from '../../lib/chatgpt/index.js';
+import pave from '../../lib/pave/index.js';
+import shortenText from '../../lib/shorten-text/index.js';
+import {
+  summarize as basicSummarize,
+  tokenBudget,
+} from '../../prompts/index.js';
+import modelService from '../../services/llm-model/index.js';
+
+const summarize = ({ budget, type, value, fixes = [] }) => {
+  if (budget) {
+    fixes.push(tokenBudget(budget));
+  }
+
+  if (type === 'code') {
+    fixes.push('Output function signature lines and a closing bracket.');
+    fixes.push(
+      'Comment out the bodies of the functions and leave a summary of the implementation.'
+    );
+    fixes.push('Remove the function header if it exists.');
+  }
+
+  const fixesAsBullets = fixes.map((fix) => ` - ${fix}`);
+
+  return chatGPT(basicSummarize(value, `${fixesAsBullets.join('\n')}`));
+};
+
+/**
+ * SummaryMap is a utility class for automatically summarizing prompt inputs
+ *   to fit within a desired desired token budget.
+ */
+export default class SummaryMap extends Map {
+  constructor({
+    maxTokensPerValue,
+    model = modelService.getBestAvailableModel(),
+    promptText,
+    targetTokens,
+    // used with promptText, when targetTokens isn't supplied
+    targetTokensTotalRatio = 0.3,
+  }) {
+    super();
+    this.cache = new Map();
+    this.data = new Map();
+    this.isCacheValid = false;
+    this.maxTokensPerValue = maxTokensPerValue ?? model.maxTokens;
+
+    if (targetTokens) {
+      this.targetTokens = targetTokens;
+    } else if (promptText && model) {
+      this.promptTokens = model.toTokens(promptText).length;
+      const maxModelTokens = model.maxTokens;
+      const remainingTokens = maxModelTokens - this.promptTokens;
+      this.targetTokens = Math.floor(
+        remainingTokens - remainingTokens * targetTokensTotalRatio
+      );
+    } else {
+      throw new Error(
+        'Either "promptText" and "model" or "targetTokens" must be provided.'
+      );
+    }
+  }
+
+  calculateBudgets() {
+    const totalSizeWeight = [...this.data.values()]
+      .filter((obj) => obj?.summary !== false)
+      .reduce((sum, valueObject) => {
+        return sum + (valueObject.weight ?? 1) * valueObject.value.length;
+      }, 0);
+    const sortedEntries = [...this.data.entries()].sort(
+      (a, b) => a[1].weight - b[1].weight
+    );
+
+    const budgets = [];
+    for (const [entryKey, valueObject] of sortedEntries) {
+      const sizeWeight = valueObject.value.length * (valueObject.weight ?? 1);
+      const budget = Math.floor(
+        (sizeWeight / totalSizeWeight) * this.targetTokens
+      );
+
+      if (valueObject.weight) {
+        budgets.push({ key: entryKey, budget });
+      } else {
+        budgets.push({ key: entryKey });
+      }
+    }
+
+    return { totalSizeWeight, budgets };
+  }
+
+  async myFillCache() {
+    const { budgets } = this.calculateBudgets();
+
+    for (const { key, budget } of budgets) {
+      const valueObject = this.data.get(key);
+
+      const value = shortenText(valueObject.value, {
+        targetTokenCount: this.maxTokensPerValue,
+      });
+
+      // omit weight to skip summarization
+      let summarizedValue = value;
+      if (budget) {
+        summarizedValue = await summarize({
+          budget,
+          fixes: valueObject.fixes,
+          type: valueObject.type,
+          value,
+        });
+      }
+
+      this.cache.set(key, summarizedValue);
+    }
+
+    this.isCacheValid = true;
+  }
+
+  getCache() {
+    return this.cache;
+  }
+
+  set(key, config) {
+    this.data.set(key, config);
+    this.cache.delete(key);
+    this.isCacheValid = false;
+  }
+
+  delete(key) {
+    this.data.delete(key);
+    this.cache.delete(key);
+    this.isCacheValid = false;
+  }
+
+  clear() {
+    this.data.clear();
+    this.cache.clear();
+    this.isCacheValid = false;
+  }
+
+  getStale(key) {
+    return this.cache.get(key);
+  }
+
+  get(key) {
+    if (!super.has(key)) {
+      return null;
+    }
+
+    if (!this.isCacheValid) {
+      return this.myFillCache()
+        .then(() => this.cache.get(key))
+        .catch((error) => {
+          return Promise.reject(error);
+        });
+    }
+
+    return Promise.resolve(this.getStale(key));
+  }
+
+  valuesStale() {
+    return this.cache.values();
+  }
+
+  values() {
+    if (!this.isCacheValid) {
+      return this.myFillCache()
+        .then(() => this.cache.values())
+        .catch((error) => {
+          return Promise.reject(error);
+        });
+    }
+    return Promise.resolve(this.valuesStale());
+  }
+
+  entriesStale() {
+    return this.cache.entries();
+  }
+
+  entries() {
+    if (!this.isCacheValid) {
+      return this.myFillCache()
+        .then(() => this.cache.entries())
+        .catch((error) => {
+          return Promise.reject(error);
+        });
+    }
+    return Promise.resolve(this.entriesStale());
+  }
+
+  pavedSummaryResultStale() {
+    return Array.from(this.entriesStale()).reduce(
+      (acc, [k, v]) => pave(acc, k, v),
+      {}
+    );
+  }
+
+  pavedSummaryResult() {
+    if (!this.isCacheValid) {
+      return this.myFillCache()
+        .then(() => this.pavedSummaryResultStale())
+        .catch((error) => {
+          return Promise.reject(error);
+        });
+    }
+    return Promise.resolve(this.pavedSummaryResultStale());
+  }
+}

package/src/chains/summary-map/index.spec.js

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import SummaryMap from './index.js';
+import pave from '../../lib/pave/index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/Pursuant to the adjudication/.test(text)) {
+      return '01234567890123456789012345678901234567890123456789';
+    }
+    if (/rabin_karp_search/.test(text)) {
+      return '0123456789012345678901234';
+    }
+    return 'undefined';
+  }),
+}));
+
+const legalText = `Pursuant to the adjudication of a force majeure clause within the context of contractual`;
+
+const codeText = `import numpy as np
+
+def rabin_karp_search(pattern, text, prime=101):
+`;
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: {
+      targetTokens: 100,
+      keys: [
+        { key: 'example.text', value: legalText, weight: 1, type: 'text' },
+        { key: 'example.code', value: codeText, weight: 0.5, type: 'code' },
+      ],
+    },
+    wants: [
+      { key: 'example.text', resultLength: 50, budget: [60, 80] },
+      { key: 'example.code', resultLength: 25, budget: [20, 40] },
+    ],
+  },
+];
+
+describe('Summary map', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const map = new SummaryMap({
+        targetTokens: example.inputs.targetTokens,
+      });
+
+      for (const input of example.inputs.keys) {
+        map.set(input.key, input);
+      }
+
+      const entries = Array.from(await map.entries());
+      const result = entries.reduce((acc, [k, v]) => pave(acc, k, v), {});
+
+      for (const want of example.wants) {
+        let value = result;
+
+        // Navigate the result object using the key segments
+        for (const keySegment of want.key.split('.')) {
+          value = value[keySegment];
+        }
+
+        expect(typeof value).toBe('string');
+
+        // Check if the length of the value is within the expected range
+        expect(value.length).toBeLessThanOrEqual(want.resultLength);
+
+        if (want.budget) {
+          const { budgets } = map.calculateBudgets();
+          const found = budgets.find((b) => b.key === want.key);
+          expect(found.budget).gt(want.budget[0]);
+          expect(found.budget).lt(want.budget[1]);
+        }
+      }
+    });
+  });
+});

package/src/chains/test/index.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { errorRunningTests } from '../../constants/messages.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import {
+  constants as promptConstants,
+  wrapVariable,
+} from '../../prompts/index.js';
+import modelService from '../../services/llm-model/index.js';
+import toObject from '../../verblets/to-object/index.js';
+
+const {
+  contentIsExample,
+  contentIsInstructions,
+  noFalseInformation,
+  onlyJSONArray,
+  onlyJSONStringArray,
+  useLineNumber,
+} = promptConstants;
+
+const contentIsChecksExamined =
+  'These items were checked in an examination of the text:';
+const contentIsExamined = 'The text examined:';
+const findCodeImprovements =
+  'Find specific improvements in the following code, not nitpicks.';
+const gatherAsTestJSON =
+  'Gather these discovered issues into a JSON format my tests module can consume.';
+
+const testExamplesJSON = `[
+  {
+    name: '<copied from the supplied checks>',
+    expected: '<what you expected to see, your rationale for the change, give suggestions here, abbreviate to < 100 characters>',
+    saw: '<what you saw, being specific about where you see it, abbreviate to < 100 characters>',
+    isSuccess: false,
+  },
+  {
+    name: '<copied from the supplied checks>',
+    expected: '<what you expected to see, your rationale for the change, give suggestions here, abbreviate to < 100 characters>',
+    saw: '<what you saw, being specific about where you see it, abbreviate to < 100 characters>',
+    isSuccess: true,
+  },
+  <many more>
+]`;
+
+const checksPrompt = (text, instructions) => `
+${contentIsInstructions} ${wrapVariable(instructions)}
+
+${wrapVariable(text, { tag: 'main-content' })}
+
+${useLineNumber}
+${noFalseInformation}
+
+${onlyJSONStringArray}
+`;
+
+const testsPrompt = (text, instructions, checks) => `${onlyJSONArray}
+
+${gatherAsTestJSON}
+
+${contentIsChecksExamined} ${wrapVariable(checks)}
+
+${contentIsExamined} ${wrapVariable(text, { tag: 'text-examined' })}
+
+${contentIsExample} ${wrapVariable(testExamplesJSON, { tag: 'example' })}
+
+${onlyJSONArray}
+`;
+
+export default async (
+  filePath,
+  instructions = findCodeImprovements,
+  model = modelService.getBestAvailableModel()
+) => {
+  const enableRegex = new RegExp(process.env.ENABLE_AI_TESTS ?? '^$');
+  if (!enableRegex.test(filePath)) {
+    return [];
+  }
+
+  try {
+    const filePathAbsolute = path.resolve(filePath);
+    const text = await fs.readFile(filePathAbsolute, 'utf-8');
+
+    const checksPromptCreated = checksPrompt(text, instructions);
+    const checksBudget = model.budgetTokens(checksPromptCreated);
+
+    const checksResult = await chatGPT(checksPromptCreated, {
+      modelOptions: {
+        maxTokens: checksBudget.completion,
+      },
+    });
+
+    const testsPromptCreated = testsPrompt(text, instructions, checksResult);
+    const testsBudget = model.budgetTokens(testsPromptCreated);
+
+    const results = await toObject(
+      await chatGPT(testsPromptCreated, {
+        modelOptions: {
+          maxTokens: testsBudget.completion,
+        },
+      })
+    );
+
+    if (!results.length) {
+      return [];
+    }
+
+    return results;
+  } catch (error) {
+    return [
+      {
+        name: errorRunningTests,
+        expected: 'tests generated',
+        saw: error.message,
+      },
+    ];
+  }
+};

package/src/chains/test-advice/index.js

@@ -0,0 +1,36 @@
+import test from '../test/index.js';
+
+const boundaryIssues =
+  'Run the code with 5 boundary value test cases and report any that fail';
+
+const successIssues =
+  'Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.';
+
+const failureIssues = `Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.`;
+
+const defectIssues =
+  'Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.';
+
+const bestPracticesIssues =
+  'Suggest 5 best practices improvements for this code.';
+
+const cleanCodeIssues = 'Suggest 5 "clean code" improvements for this code.';
+
+const qualityIssues =
+  'Identify 5 specific issues related to code quality, readability, and maintainability.';
+
+const refactorIssues =
+  'Suggest 5 refactors that would most improve the composibility of this code.';
+
+export default async (path) => {
+  return [
+    ...(await test(path, boundaryIssues)),
+    ...(await test(path, successIssues)),
+    ...(await test(path, failureIssues)),
+    ...(await test(path, defectIssues)),
+    ...(await test(path, bestPracticesIssues)),
+    ...(await test(path, cleanCodeIssues)),
+    ...(await test(path, qualityIssues)),
+    ...(await test(path, refactorIssues)),
+  ];
+};

package/src/constants/common.js

@@ -0,0 +1,9 @@
+/* eslint-disable import/prefer-default-export */
+
+export const longTestTimeout = 120000;
+
+export const maxRetries = 3;
+
+export const retryDelay = 1000;
+
+export const debugToObject = process.env.DEBUG_TO_OBJECT ?? false;

package/src/constants/messages.js

@@ -0,0 +1,3 @@
+export const retryJSONParse =
+  'The JSON parsing module will attempt recovery via internal retry. This message only appears in dev.';
+export const errorRunningTests = 'Error running AI tests';

package/src/constants/openai.js

@@ -0,0 +1,65 @@
+/* eslint-disable no-unused-expressions, import/prefer-default-export */
+
+// Importing dotenv config to load environment variables from .env file
+// eslint-disable-next-line no-unused-vars
+import dotenv from 'dotenv/config';
+
+import chai from 'chai';
+
+const { expect } = chai;
+
+// eslint-disable-next-line no-underscore-dangle
+const _models = {
+  gpt35Turbo: {
+    endpoint: 'v1/chat/completions',
+    name: 'gpt-3.5-turbo-1106',
+    maxTokens: 16386,
+    requestTimeout: 40000,
+  },
+  textDavinci003: {
+    endpoint: 'v1/completions',
+    name: 'text-davinci-003',
+    maxTokens: 4097,
+    requestTimeout: 15000,
+  },
+};
+
+if (process.env.CHATGPT_V4_ENABLED) {
+  _models.gpt4 = {
+    endpoint: 'v1/chat/completions',
+    name: 'gpt-4-0125-preview',
+    maxTokens: 128000,
+    requestTimeout: 50000,
+  };
+}
+
+expect(process.env.OPENAI_API_KEY).to.exist;
+
+export const apiKey = process.env.OPENAI_API_KEY;
+
+export const apiUrl = 'https://api.openai.com/';
+
+const secondsInDay = 60 * 60 * 24;
+export const cacheTTL = process.env.CHATGPT_CACHE_TTL ?? secondsInDay;
+
+export const debugPromptGlobally = process.env.CHATGPT_DEBUG_REQUEST ?? false;
+
+export const debugPromptGloballyIfChanged =
+  process.env.CHATGPT_DEBUG_REQUEST_IF_CHANGED ?? false;
+
+export const debugResultGlobally = process.env.CHATGPT_DEBUG_RESPONSE ?? false;
+
+export const debugResultGloballyIfChanged =
+  process.env.CHATGPT_DEBUG_RESPONSE_IF_CHANGED ?? false;
+
+export const frequencyPenalty = process.env.CHATGPT_FREQUENCY_PENALTY ?? 0;
+
+export const models = _models;
+
+export const operationTimeoutMultiplier = 2;
+
+export const presencePenalty = process.env.CHATGPT_PRESENCE_PENALTY ?? 0;
+
+export const temperature = process.env.CHATGPT_TEMPERATURE ?? 0;
+
+export const topP = process.env.CHATGPT_TOPP ?? 0.5;

package/src/index.js

@@ -0,0 +1,33 @@
+ // Importing dotenv config to load environment variables from .env file
+// eslint-disable-next-line no-unused-vars
+import dotenv from 'dotenv/config';
+
+export { default as Dismantle } from './chains/dismantle/index.js';
+export { default as list } from './chains/list/index.js';
+
+export { default as questions } from './chains/questions/index.js';
+export { default as scanJS } from './chains/scan-js/index.js';
+export { default as sort } from './chains/sort/index.js';
+export { default as SummaryMap } from './chains/summary-map/index.js';
+
+export { default as schemas } from './json-schemas/index.js';
+
+import chatGPT from './lib/chatgpt/index.js';
+export { default as retry } from './lib/retry/index.js';
+export { default as stripResponse } from './lib/strip-response/index.js';
+export { default as searchJSFiles } from './lib/search-js-files/index.js';
+
+export * as prompts from './prompts/index.js';
+
+export { getClient as getRedis } from './services/redis/index.js';
+
+export { default as auto } from './verblets/auto/index.js';
+export { default as bool } from './verblets/bool/index.js';
+export { default as enums } from './verblets/enum/index.js';
+export { default as intent } from './verblets/intent/index.js';
+export { default as number } from './verblets/number/index.js';
+export { default as schemaOrg } from './verblets/schema-org/index.js';
+export { default as toObject } from './verblets/to-object/index.js';
+
+
+export default chatGPT;

package/src/json-schemas/cars-test.json

@@ -0,0 +1,11 @@
+{
+  "type": "object",
+  "properties": {
+    "make": { "type": "string" },
+    "model": { "type": "string" },
+    "releaseDate": { "type": "string", "format": "date-time" },
+    "maxRange": { "type": "number", "description": "Max range in miles" },
+    "batteryCapacity": { "type": "number", "description": "Battery capacity in kWh" },
+    "startingCost": { "type": "number", "description": "Starting cost in USD" }
+  }
+}

package/src/json-schemas/index.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs/promises';
+
+const schemaFileNames = [
+  '../verblets/bool/index.schema.json',
+  '../chains/list/schema.json'
+];
+
+const schemas = [];
+
+for (let schemaFileName of schemaFileNames) {
+  const schemaText = await fs.readFile(
+    new URL(schemaFileName, import.meta.url)
+  );
+  const schema = JSON.parse(schemaText);
+  schemas.push(schema)
+}
+
+export default schemas;

package/src/json-schemas/intent.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://example.com/schemas/intent-schema.json",
+  "type": "object",
+  "properties": {
+    "queryText": {
+      "type": "string",
+      "description": "The user's query text."
+    },
+    "intent": {
+      "type": "object",
+      "properties": {
+        "operation": {
+          "type": "string",
+          "description": "The operation associated with the intent."
+        },
+        "displayName": {
+          "type": "string",
+          "description": "The display name of the intent."
+        }
+      },
+      "required": ["operation", "displayName"],
+      "description": "Information about the intent."
+    },
+    "parameters": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Parameters associated with the intent."
+    },
+    "optionalParameters": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Optional parameters associated with the intent."
+    }
+  },
+  "required": ["queryText", "intent"],
+  "description": "Schema for an intent response."
+}