@far-world-labs/verblets 0.1.1

package/src/lib/prompt-cache/index.js

@@ -0,0 +1,46 @@
+import crypto from 'node:crypto';
+import * as R from 'ramda';
+
+import { cacheTTL } from '../../constants/openai.js';
+
+const variableKeys = ['created', 'id', 'max_tokens', 'usage'];
+
+const sortKeys = (data) => {
+  const sortedData = R.sortBy(R.identity, R.keys(data)).reduce((acc, key) => {
+    acc[key] = key === 'messages' ? data[key]?.[0]?.content : data[key];
+    return acc;
+  }, {});
+
+  return sortedData;
+};
+
+export const toKey = (data) => {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(sortKeys(data)))
+    .digest('hex')
+    .toString();
+};
+
+export const get = async (redis, inputData) => {
+  const resultFromRedis = await redis.get(
+    toKey(R.omit(variableKeys, inputData))
+  );
+
+  const foundInRedis = !!resultFromRedis;
+
+  let result;
+  if (foundInRedis) {
+    result = JSON.parse(resultFromRedis);
+  }
+
+  return { created: !foundInRedis, result };
+};
+
+export const set = async (redis, inputData, outputData) => {
+  await redis.set(
+    toKey(R.omit(variableKeys, inputData)),
+    JSON.stringify(outputData),
+    { EX: cacheTTL }
+  );
+};

package/src/lib/retry/index.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-await-in-loop */
+import {
+  maxRetries as maxRetriesDefault,
+  retryDelay as retryDelayDefault,
+} from '../../constants/common.js';
+
+export default async (
+  fn,
+  {
+    label = '',
+    maxRetries = maxRetriesDefault,
+    retryDelay = retryDelayDefault,
+    retryOnAll = true,
+  } = {}
+) => {
+  let retry = 0;
+  let lastError = new Error('Nothing to run');
+
+  // eslint-disable-next-line no-promise-executor-return
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  const labelDisplay = label ? `"${label}"` : '';
+
+  while (retry <= maxRetries) {
+    try {
+      if (label) {
+        const variables = [`retry: ${retry}`].join(', ');
+        const startTag = `${retry > 0 ? 'retry' : 'started'}`;
+        const startVariablesDisplay = `${retry > 0 ? ` (${variables})` : ''}`;
+        console.error(
+          `Run ${labelDisplay} [${startTag}]${startVariablesDisplay}`
+        );
+      }
+
+      const result = await fn();
+
+      if (label) {
+        console.error(`Run ${labelDisplay} [complete]`);
+      }
+
+      return result;
+    } catch (error) {
+      lastError = error;
+
+      const isRetry =
+        retryOnAll || (error.response && error.response.status === 429);
+
+      if (isRetry) {
+        await sleep(retryDelay * retry);
+        retry += 1;
+      } else {
+        retry = maxRetries;
+      }
+      const doneTag = `${retry >= maxRetries ? 'abort' : 'retry'}`;
+
+      if (label) {
+        console.error(`Run ${labelDisplay} [${doneTag}]: ${error.message}`);
+      }
+    }
+  }
+
+  throw lastError;
+};

package/src/lib/retry/index.spec.js

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+
+import retry from './index.js';
+
+const retryDelayGlobal = 10;
+
+const mockFn = () => {
+  return 'Success';
+};
+
+describe('Retry', () => {
+  it('Succeeds on first attempt', async () => {
+    const result = await retry(mockFn, { retryDelay: retryDelayGlobal });
+    expect(result).toStrictEqual('Success');
+  });
+
+  it('Succeeds after retrying', async () => {
+    let callCount = 0;
+    const fn = async () => {
+      callCount += 1;
+      if (callCount === 1) {
+        const error = new Error('Error 429');
+        error.response = { status: 429 };
+        throw error;
+      }
+      return 'Success';
+    };
+
+    const result = await retry(fn, { retryDelay: retryDelayGlobal });
+    expect(result).toStrictEqual('Success');
+    expect(callCount).toStrictEqual(2);
+  });
+
+  it('Fails after maxRetries', async () => {
+    const maxRetries = 2;
+    let callCount = 0;
+
+    const fn = async () => {
+      callCount += 1;
+      const error = new Error('Error 429');
+      error.response = { status: 429 };
+      throw error;
+    };
+
+    try {
+      await retry(fn, { maxRetries, retryDelay: retryDelayGlobal });
+    } catch (error) {
+      expect(error.message).toStrictEqual('Error 429');
+      expect(callCount).toStrictEqual(maxRetries + 1);
+    }
+  });
+
+  it('Throws non-retryable error', async () => {
+    const mockFnWithOtherError = () => {
+      throw new Error('Error 500');
+    };
+
+    try {
+      await retry(mockFnWithOtherError, { retryDelay: retryDelayGlobal });
+    } catch (error) {
+      expect(error.message).toStrictEqual('Error 500');
+    }
+  });
+
+  it('Retries on all errors when retryOnAll is true', async () => {
+    let callCount = 0;
+    const maxRetries = 2;
+    const fn = async () => {
+      callCount += 1;
+      const error = new Error('Error 500');
+      error.response = { status: 500 };
+      throw error;
+    };
+
+    try {
+      await retry(fn, {
+        maxRetries,
+        retryDelay: retryDelayGlobal,
+        retryOnAll: true,
+      });
+    } catch (error) {
+      expect(error.message).toStrictEqual('Error 500');
+      expect(callCount).toStrictEqual(maxRetries + 1);
+    }
+  });
+});

package/src/lib/search-best-first/index.js

@@ -0,0 +1,66 @@
+import * as R from 'ramda';
+
+const hasOwnToString = (obj) => {
+  return obj.toString !== Object.prototype.toString;
+};
+
+const visitDefault = () => {
+  return Promise.reject(new Error('Not Implemented'));
+};
+
+const nextDefault = () => {
+  return Promise.reject(new Error('Not Implemented'));
+};
+
+const rankDefault = () => {
+  return Promise.reject(new Error('Not Implemented'));
+};
+
+const filterWith = (state) => (nextNode) => {
+  return !state.visited.has(
+    hasOwnToString(nextNode) ? nextNode.toString() : nextNode
+  );
+};
+
+export default async ({
+  next = nextDefault,
+  node: rootNode,
+  rank = rankDefault,
+  state: stateInitial = {},
+  visit = visitDefault,
+}) => {
+  let nodesTodo = [rootNode];
+  let state = stateInitial;
+  if (!state.visited) {
+    state.visited = new Set();
+  }
+
+  while (nodesTodo.length > 0) {
+    // eslint-disable-next-line no-await-in-loop
+    const nodesRanked = await rank({ nodes: nodesTodo, state });
+    const node = nodesRanked.shift();
+
+    const nodesTodoNext = nodesTodo.filter((el) =>
+      hasOwnToString(node) ? el.toString() !== node.toString() : el !== node
+    );
+
+    state.visited.add(hasOwnToString(node) ? node.toString() : node);
+
+    // eslint-disable-next-line no-await-in-loop
+    state = await visit({ node, state });
+
+    // eslint-disable-next-line no-await-in-loop
+    const nextNodes = await next({ node, state });
+
+    nodesTodo = R.unionWith(
+      (nodeA, nodeB) =>
+        hasOwnToString(nodeA)
+          ? nodeA.toString() === nodeB.toString()
+          : nodeA === nodeB,
+      nodesTodoNext,
+      nextNodes.filter(filterWith(state))
+    );
+  }
+
+  return state;
+};

package/src/lib/search-js-files/code-features-property-definitions.json

@@ -0,0 +1,123 @@
+[
+  {
+    "name": "singlePurpose",
+    "criteria": "Ensure each function performs only one task, avoiding unrelated operations within the function.",
+    "score0": "0.0 indicates the function combines multiple tasks, like reading data, processing it, and displaying results.",
+    "score1": "1.0 indicates the function has a clear single purpose, such as reading data or validating input."
+  }, {
+    "name": "clearNaming",
+    "criteria": "Verify function names clearly describe their purpose, making it easier to identify their responsibilities.",
+    "score0": "0.0 indicates the function name like getUserData accurately reflects its purpose, improving code readability.",
+    "score1": "1.0 indicates the function name like processData is vague or misleading, making it difficult to understand its purpose."
+  }, {
+    "name": "smallSize",
+    "criteria": "Check if functions are short and focused.",
+    "score0": "0.0 indicates the function is concise, having 10 or fewer lines of code.",
+    "score1": "1.0 indicates the function is excessively long, with over 50 lines of code."
+  }, {
+    "name": "limitedParameters",
+    "criteria": "Examine the function parameters; a high number may suggest additional responsibilities.",
+    "score0": "0.0 indicates the function has 0-2 parameters, allowing for easy understanding and use.",
+    "score1": "1.0 indicates the function has more than 5 parameters, leading to confusion and decreased readability."
+  }, {
+    "name": "interfaceToImplementation",
+    "criteria": "Examine the interface to the input and output. Does the difficulty of the interface justify the power of its implementation?",
+    "score0": "0.0 indicates the interface is simple and efficient, providing a powerful implementation without unnecessary complexity",
+    "score1": "1.0 indicates the interface is overly complex or convoluted relative to the complexity of its implementation."
+  }, {
+    "name": "noSideEffects",
+    "criteria": "Ensure functions don't produce unexpected changes to external state; check for global variable modifications.",
+    "score0": "0.0 indicates the function has no side effects, as it doesn't modify global variables or external state.",
+    "score1": "1.0 indicates the function modifies global variables or external state, causing unpredictability."
+  }, {
+    "name": "reusability",
+    "criteria": "Verify if functions are modular and can be reused easily in different contexts.",
+    "score0": "0.0 indicates the function is generic, like a formatDate function that can be used in multiple scenarios.",
+    "score1": "1.0 indicates the function is tightly coupled to a specific module, limiting its reusability."
+  }, {
+    "name": "lowCoupling",
+    "criteria": "Check for minimal dependencies between functions, making them more independent and maintainable.",
+    "score0": "0.0 indicates the function has no dependencies on other functions, making it easy to use and maintain.",
+    "score1": "1.0 indicates the function relies heavily on other functions, increasing complexity and reducing maintainability."
+  }, {
+    "name": "separationOfConcerns",
+    "criteria": "Verify if distinct responsibilities are organized into separate functions or modules.",
+    "score0": "0.0 indicates the function is well-organized, with distinct responsibilities like data fetching or validation in separate functions.",
+    "score1": "1.0 indicates the function combines multiple responsibilities like data fetching and processing, leading to confusion."
+  }, {
+    "name": "easyTestability",
+    "criteria": "Check if functions can be tested independently.",
+    "score0": "0.0 indicates the function is stateless and doesn't depend on external systems, making testing straightforward.",
+    "score1": "1.0 indicates the function is difficult to test, possibly due to complex dependencies or state management."
+  }, {
+    "name": "mixedAbstractionLevels",
+    "criteria": "Check if the function speaks in a consistent level of abstraction, avoiding mixing high-level logic with low-level implementation details.",
+    "score0": "0.0 indicates the function has a highly-consistent level of abstraction",
+    "score1": "1.0 indicates the function hopelessly mixes high-level logic with low-level implementation details"
+  }, {
+    "name": "mixedConcepts",
+    "criteria": "Check if the function speaks in a consistent topic, neither confusing the metaphors or changing topics.",
+    "score0": "0.0 indicates the function maintains a consistent topic, like handling user authentication without mixing unrelated topics.",
+    "score1": "1.0 indicates the function changes topics or mixes metaphors, such as combining user authentication with unrelated tasks like data processing."
+  }, {
+    "name": "businessLogic",
+    "criteria": "Look for the presence of business logic within the function, ensuring it's clearly defined and separated from other concerns.",
+    "score0": "0.0 indicates the function has clearly defined business logic, separate from other concerns like data access or UI rendering.",
+    "score1": "1.0 indicates the function mixes business logic with other concerns, like data access, making it difficult to understand and maintain."
+  }, {
+    "name": "networkCalls",
+    "criteria": "Check if the function makes network calls, and if so, ensure they are handled appropriately.",
+    "score0": "0.0 indicates the function doesn't make network calls or handles them correctly, separating concerns and managing errors.",
+    "score1": "1.0 indicates the function makes network calls without proper error handling or mixes them with unrelated responsibilities."
+  }, {
+    "name": "diskCalls",
+    "criteria": "Examine if the function interacts with the filesystem, and if so, ensure it's done appropriately.",
+    "score0": "0.0 indicates the function doesn't interact with the filesystem or does so with proper error handling and separation of concerns.",
+    "score1": "1.0 indicates the function interacts with the filesystem inappropriately, mixing concerns or lacking error handling."
+  }, {
+    "name": "databaseCalls",
+    "criteria": "Verify if the function makes database calls, and if so, ensure they are managed appropriately.",
+    "score0": "0.0 indicates the function doesn't make database calls or handles them correctly, with proper separation of concerns and error handling.",
+    "score1": "1.0 indicates the function makes database calls without proper error handling or mixes them with unrelated responsibilities."
+  }, {
+    "name": "userInput",
+    "criteria": "Check if the function handles user input, and if so, ensure input validation and proper error handling are implemented.",
+    "score0": "0.0 indicates the function doesn't handle user input or handles it correctly with proper validation and error handling.",
+    "score1": "1.0 indicates the function handles user input without proper validation or error handling, potentially leading to security risks."
+  }, {
+    "name": "primitiveObsession",
+    "criteria": "Check for the use of primitives when objects or more descriptive data structures would be better, especially in interfaces to other modules.",
+    "score0": "0.0 indicates the function uses appropriate data structures or objects instead of primitives, improving code readability and maintainability.",
+    "score1": "1.0 indicates the function relies heavily on primitives, making the code less readable and harder to maintain."
+  }, {
+    "name": "chatGPTUsage",
+    "criteria": "How frequently and effectively is the chatGPT function used in the code?",
+    "score0": "0.0 indicates the chatGPT function is not used or used ineffectively.",
+    "score1": "1indicates the chatGPT function is used frequently and effectively."
+  }, {
+    "name": "modelBudgetAndTokenManagement",
+    "criteria": "How well does the code handle model budgeting and token management?",
+    "score0": "0.0 indicates poor management of model budget and token management.",
+    "score1": "1indicates efficient management of model budget and token management."
+  }, {
+    "name": "textProcessingUtilities",
+    "criteria": "How well does the code utilize text processing utilities for tasks like shortening or sanitizing text?",
+    "score0": "0.0 indicates not using text processing utilities or using them ineffectively.",
+    "score1": "1indicates using text processing utilities effectively. Prompt text, token management, prompt template literals, and prompt string concatenations are another category--they are not considered text processing utilities."
+  }, {
+    "name": "promptConstruction",
+    "criteria": "How well does the code construct prompts using template literals, string concatenation, or constant declarations?",
+    "score0": "0.0 indicates poorly constructed prompts.",
+    "score1": "1indicates well-constructed prompts."
+  }, {
+    "name": "textWrappingUtilities",
+    "criteria": "How effectively does the code use text wrapping utilities for managing input and output text?",
+    "score0": "0.0 indicates not using text wrapping utilities or using them ineffectively.",
+    "score1": "1indicates using text wrapping utilities effectively."
+  }, {
+    "name": "spellingAndGrammar",
+    "criteria": "Check for spelling or grammar mistakes in any English text that is written.",
+    "score0": "0.0 indicates the text has no spelling or grammar mistakes, ensuring readability and clarity.",
+    "score1": "1indicates the text is filled with spelling or grammar mistakes, to the point of incomprehensibility."
+  }
+]

package/src/lib/search-js-files/index.examples.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+
+import search from './index.js';
+
+const examples = [
+  {
+    inputs: { filename: './src/lib/chatgpt/index.js' },
+    want: { foundFiles: 30 },
+  },
+];
+
+describe('Scan JS repo with best-first search', () => {
+  examples.forEach((example) => {
+    it(example.inputs.text, async () => {
+      const result = await search({ node: example.inputs });
+
+      if (example.want.foundFiles) {
+        expect(result.visited.size).toBeGreaterThan(example.want.foundFiles);
+      }
+    });
+  });
+});

package/src/lib/search-js-files/index.js

@@ -0,0 +1,158 @@
+/* eslint-disable no-await-in-loop */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import parseJSParts from '../parse-js-parts/index.js';
+import search from '../search-best-first/index.js';
+
+export class Node {
+  constructor(args) {
+    Object.assign(this, args);
+  }
+
+  toString() {
+    return `${this.filename}:::${this.functionName ?? ''}`;
+  }
+}
+
+const processLocalImport = async (source) => {
+  const importedFile = await fs.readFile(source, 'utf8');
+  const parsedImport = parseJSParts(source, importedFile);
+  return Object.entries(parsedImport.functionsMap).map(
+    ([importKey, importValue]) => ({
+      filename: source,
+      functionName: importValue?.functionName ?? importKey,
+      functionData: importValue,
+    })
+  );
+};
+
+const processNpmImport = async (source, includeNodeModules = false) => {
+  if (!includeNodeModules) return [];
+
+  try {
+    const packageJson = JSON.parse(await fs.readFile('./package.json', 'utf8'));
+    if (
+      packageJson.dependencies[source] ||
+      packageJson.devDependencies[source]
+    ) {
+      const nodeModulePath = `./node_modules/${source}`;
+      const npmPackageJson = JSON.parse(
+        await fs.readFile(`${nodeModulePath}/package.json`, 'utf8')
+      );
+      const mainFilePath = npmPackageJson.main || 'index.js';
+      const importedFile = await fs.readFile(
+        `${nodeModulePath}/${mainFilePath}`,
+        'utf-8'
+      );
+      const parsedImport = parseJSParts(mainFilePath, importedFile);
+
+      return Object.entries(parsedImport.functionsMap).map(
+        ([importKey, importValue]) => ({
+          filename: `${nodeModulePath}/${mainFilePath}`,
+          functionName: importKey,
+          functionData: importValue,
+        })
+      );
+    }
+  } catch (error) {
+    console.error(
+      `Process npm import [error]: ${error.message} (source: ${source})`
+    );
+  }
+
+  return [];
+};
+
+const visitDefault = ({ state }) => {
+  if (process.env.NODE_ENV === 'development') {
+    // console.error(`Visiting: ${node.filename} - ${node.functionName}`);
+  }
+  return state;
+};
+
+const rank = ({ nodes }) => {
+  // Example: Rank by the length of the function name
+  return nodes.sort(
+    (a, b) =>
+      (a.functionName ?? a.filename).length -
+      (b.functionName ?? b.filename).length
+  );
+};
+
+const prepareNext = async ({ node, includeNodeModules }) => {
+  const code = await fs.readFile(node.filename, 'utf-8');
+  const parsed = parseJSParts(node.filename, code);
+
+  const functionsFound = Object.entries(parsed.functionsMap).map(
+    ([, value]) => {
+      return new Node({
+        ...value,
+        filename: node.filename,
+      });
+    }
+  );
+
+  const importPromises = Object.values(parsed.importsMap).map((importData) => {
+    if (
+      importData.source.startsWith('./') ||
+      importData.source.startsWith('../') ||
+      importData.source.startsWith('/')
+    ) {
+      const resolvedPath = path.resolve(
+        path.dirname(node.filename),
+        importData.source
+      );
+
+      return processLocalImport(resolvedPath);
+    }
+    return processNpmImport(importData.source, includeNodeModules);
+  });
+
+  const importFunctions = await Promise.all(importPromises);
+  const importsFound = importFunctions.reduce((acc, importedFuncs) => {
+    return [
+      ...acc,
+      ...importedFuncs.map(
+        (f) =>
+          new Node({
+            ...f,
+            ...f.functionData,
+            functionData: undefined,
+            // not including function names in the imports knowing we will scan the file for them better
+            functionName: undefined,
+          })
+      ),
+    ];
+  }, []);
+
+  return {
+    functions: functionsFound,
+    imports: importsFound,
+  };
+};
+
+const nextDefault = ({ state }) => {
+  return state.jsElements.imports.concat(state.jsElements.functions);
+};
+
+export default ({
+  next: nextExternal = nextDefault,
+  node: nodeInitial,
+  visit: visitExternal = visitDefault,
+  includeNodeModules,
+  ...options
+}) => {
+  return search({
+    ...options,
+    next: async ({ node, state }) => {
+      const jsElements = await prepareNext({ node, includeNodeModules });
+      return nextExternal({ node, state: { jsElements, ...state } });
+    },
+    node: new Node(nodeInitial),
+    rank,
+    visit: ({ node, state }) => {
+      return visitExternal({ node, state });
+    },
+  });
+};

package/src/lib/search-js-files/index.spec.js

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