@far-world-labs/verblets 0.1.1

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@far-world-labs/verblets",
+  "version": "0.1.1",
+  "description": "OpenAI Client",
+  "main": "index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Far-World-Labs/Verblets.git"
+  },
+  "scripts": {
+    "start": "node scripts/runner/index.js",
+    "dev": "nodemon --no-warnings scripts/runner/index.js",
+    "editor": "node scripts/simple-editor/index.js",
+    "--": "npm run script -- generate-verblet foo",
+    "script": "./scripts/run.sh",
+    "test": "vitest",
+    "examples": "EXAMPLES=true vitest --config .vite.config.examples.js",
+    "lint": "eslint 'src/**/*.{js,jsx}'",
+    "lint:fix": "eslint 'src/**/*.{js,jsx}' --fix",
+    "husky:install": "husky install",
+    "husky:uninstall": "husky uninstall",
+    "prepare": "npx husky install"
+  },
+  "config": {
+    "gen-script": "./scripts/run.sh gen-$1"
+  },
+  "author": "Far World Labs",
+  "license": "All Rights Reserved",
+  "dependencies": {
+    "acorn": "^8.8.2",
+    "acorn-walk": "^8.2.0",
+    "ajv": "^8.12.0",
+    "chai": "^4.3.7",
+    "change-case": "^4.1.2",
+    "dependency-tree": "^10.0.1",
+    "dotenv": "^16.0.3",
+    "gpt-tokenizer": "^2.1.2",
+    "gpt4-tokenizer": "^1.3.0",
+    "mocha": "^10.2.0",
+    "node-fetch": "^3.3.0",
+    "nodemon": "^2.0.22",
+    "ramda": "^0.29.0",
+    "redis": "^4.6.5",
+    "uuid": "^9.0.0",
+    "vitest": "^0.30.1",
+    "yargs": "^17.7.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.3",
+    "eslint": "^8.39.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jest": "^27.2.1",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "husky": "^8.0.3",
+    "install-peerdeps": "^3.0.3",
+    "lint-staged": "^13.2.2",
+    "node-record-lpcm16": "^1.0.1",
+    "npm-check": "^6.0.1",
+    "prettier": "^2.8.8",
+    "release-it": "^15.10.1",
+    "whisper-node": "^1.1.1",
+    "why-is-node-running": "^2.2.2"
+  },
+  "lint-staged": {
+    "**/*.js": [
+      "npm run lint:fix"
+    ]
+  }
+}

package/scripts/generate-chain/index.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  camelCase,
+  paramCase,
+  sentenceCase,
+} from 'change-case';
+
+const chainName = process.argv[2];
+
+if (!chainName) {
+  console.error('Please specify a chain name.');
+  process.exit(1);
+}
+
+const chainDir = `./src/chains/${paramCase(chainName)}`;
+const indexFile = `${chainDir}/index.js`;
+const testFile = `${chainDir}/index.spec.js`;
+const exampleFile = `${chainDir}/index.examples.js`;
+
+const createFileIfNotExists = (filePath, fileContent, fileType) => {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, fileContent);
+    console.error(`Created new ${fileType} file: ${filePath}`);
+  } else {
+    console.error(`Creating ${fileType} file [skipped]: '${filePath}' exists`);
+  }
+}
+
+// Check if the chain directory already exists
+if (!fs.existsSync(chainDir)) {
+  // Create the chain directory
+  fs.mkdirSync(chainDir, { recursive: true });
+}
+
+const indexContent = `
+export default async (text) => {
+  // TODO: Implement ${paramCase(chainName)} chain
+};
+`;
+createFileIfNotExists(indexFile, indexContent, 'module file');
+
+const testContent = `import { describe, expect, it, vi } from 'vitest';
+
+import ${camelCase(chainName)} 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('${sentenceCase(chainName)} chain', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await ${camelCase(chainName)}(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});
+`;
+createFileIfNotExists(testFile, testContent, 'test');
+
+const exampleContent = `import { describe, expect, it, vi } from 'vitest';
+
+import ${camelCase(chainName)} from './index.js';
+
+const examples = [
+  {
+    inputs: { text: 'test' },
+    want: { result: true }
+  }
+];
+
+describe('${sentenceCase(chainName)} chain', () => {
+  examples.forEach((example) => {
+    it(example.inputs.text, async () => {
+      const result = await ${camelCase(chainName)}(example.inputs.text)
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+
+      if (example.want.result) {
+        expect(result)
+          .toStrictEqual(example.want.result);
+      }
+    });
+  });
+});
+`;
+createFileIfNotExists(exampleFile, exampleContent, 'example');
+
+console.error(`Created new chain: ${chainName}`);

package/scripts/generate-lib/index.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import {
+  camelCase,
+  paramCase,
+  sentenceCase,
+} from 'change-case';
+
+const libName = process.argv[2];
+
+if (!libName) {
+  console.error('Please specify a library name.');
+  process.exit(1);
+}
+
+const libDir = `./src/lib/${paramCase(libName)}`;
+const indexFile = `${libDir}/index.js`;
+const testFile = `${libDir}/index.spec.js`;
+
+const createFileIfNotExists = (filePath, fileContent, fileType) => {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, fileContent);
+    console.error(`Created new ${fileType} file: ${filePath}`);
+  } else {
+    console.error(`Creating ${fileType} file [skipped]: '${filePath}' exists`);
+  }
+}
+
+// Check if the lib directory already exists
+if (!fs.existsSync(libDir)) {
+  // Create the lib directory
+  fs.mkdirSync(libDir, { recursive: true });
+}
+
+const indexContent = `
+export default async (text) => {
+  // TODO: Implement ${paramCase(libName)} lib
+};
+`;
+createFileIfNotExists(indexFile, indexContent, 'module file');
+
+const testContent = `import { describe, expect, it, vi } from 'vitest';
+
+import ${camelCase(libName)} from './index.js';
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'test' },
+    want: { result: true }
+  }
+];
+
+describe('${sentenceCase(libName)} lib', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await ${camelCase(libName)}(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});
+`;
+createFileIfNotExists(testFile, testContent, 'test');
+
+console.error(`Created new lib: ${libName}`);

package/scripts/generate-test/index.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import parseJSParts from '../../src/lib/parse-js-parts/index.js';
+import
+chatGPT,
+{
+  getRedis,
+  SummaryMap
+} from '../../src/index.js';
+
+const modulePath = process.argv[2];
+const functionName = process.argv[3];
+
+if (!modulePath) {
+  console.error('Please specify a module to test.');
+  process.exit(1);
+}
+
+try {
+  await fs.stat(modulePath);
+} catch (err) {
+  console.error(`Module not found at: ${modulePath}`);
+  process.exit(1);
+}
+
+const moduleDir = path.dirname(modulePath);
+const moduleName = path.basename(moduleDir);
+const testFile = path.join(moduleDir, `${moduleName}.spec.js`);
+
+const examplePath1 = './src/lib/parse-js-parts/parse-js-parts.spec.js';
+
+try {
+  await fs.stat(examplePath1);
+} catch (error) {
+  console.error(`Generate test [error]: ${error.message}`);
+  process.exit(1);
+}
+
+const generatePrompt = ({ moduleFile, modulePath, examples=[] }) => {
+  const examplesJoined = examples.map((example) => `<example>${example}</example>`).join('\n');
+
+  let prompt = `Generate a test file for module shown below.
+
+Examples to inform the results:
+${examplesJoined}
+
+<module-to-test>${moduleFile}</module-to-test>`;
+
+  return prompt;
+}
+
+async function generateTestFile(modulePath) {
+  const moduleFile = await fs.readFile(modulePath, 'utf-8');
+
+  const example1 = (await fs.readFile(examplePath1, 'utf-8'));
+  // const example2 = await fs.readFile(examplePath2, 'utf-8');
+
+  const fixes = [];
+  if (functionName) {
+    fixes.push('For the function "${functionName}", keep as much of the code as you can.');
+  }
+
+  let functionNameDisplay = '';
+  if (functionName) {
+    functionNameDisplay = `, only for "${functionName}"`
+  }
+
+  let moduleFileSliced = moduleFile;
+  if (functionName) {
+    const results = parseJSParts(modulePath, moduleFile);
+
+    const funcs = Object.keys(results.functionsMap);
+    const funcFound = funcs.find(f => (new RegExp(`${functionName}$`)).test(f));
+    const funcDefFound = results.functionsMap?.[funcFound];
+    if (funcDefFound) {
+      moduleFileSliced = moduleFile.slice(funcDefFound.start, funcDefFound.end);
+    }
+  }
+
+  const argsMap = new SummaryMap({ promptText: generatePrompt.toString() });
+
+  argsMap.set('functionName', { value: functionName });
+  argsMap.set('modulePath', { value: modulePath });
+  argsMap.set('moduleFile', {
+    value: moduleFileSliced,
+    weight: 1,
+    type: 'code',
+    fixes,
+  })
+  argsMap.set('examples.0', {
+    value: example1,
+    weight: 1,
+    type: 'code',
+    fixes: ['Keep at least one of the example definitions in the example array'],
+  })
+
+  const prompt = await generatePrompt(await argsMap.pavedSummaryResult());
+
+  console.error(prompt)
+
+  const response = await chatGPT(prompt);
+
+  // use standard shell IO to apply the generated code
+  console.error(response);
+}
+
+// Example usage:
+await generateTestFile(modulePath);
+
+await (await getRedis()).disconnect();

package/scripts/generate-verblet/README.md

@@ -0,0 +1,17 @@
+# Verblet Generator
+
+This is a Node script that generates a new "verblet" module and test file in a specific directory structure.
+
+## Usage
+
+To use this script, run the following command:
+
+```
+npm run script -- generate-verblet [verblet-name]
+```
+
+Replace `[verblet-name]` with the name of your new verblet. The script will create a new directory called `./src/verblets/[verblet-name]` and generate an `index.js` file and a test file inside that directory.
+
+The generated `index.js` file exports a single default async function that you can implement to define the behavior of the verblet.
+
+The generated test file is located at `./src/verblets/[verblet-name]/[verblet-name].spec.js`. It contains a sample test that you can modify to test your verblet implementation.

package/scripts/generate-verblet/index.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import {
+  camelCase,
+  paramCase,
+  sentenceCase,
+} from 'change-case';
+
+const verbletName = process.argv[2];
+
+if (!verbletName) {
+  console.error('Please specify a verblet name.');
+  process.exit(1);
+}
+
+const verbletDir = `./src/verblets/${paramCase(verbletName)}`;
+const indexFile = `${verbletDir}/index.js`;
+const testFile = `${verbletDir}/index.spec.js`;
+const exampleFile = `${verbletDir}/index.examples.js`;
+
+const createFileIfNotExists = (filePath, fileContent, fileType) => {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, fileContent);
+    console.error(`Created new ${fileType} file: ${filePath}`);
+  } else {
+    console.error(`Creating ${fileType} file [skipped]: '${filePath}' exists`);
+  }
+}
+
+// Check if the verblet directory already exists
+if (!fs.existsSync(verbletDir)) {
+  // Create the verblet directory
+  fs.mkdirSync(verbletDir, { recursive: true });
+}
+
+const indexContent = `
+export default async (text) => {
+  // TODO: Implement ${paramCase(verbletName)} verblet
+};
+`;
+createFileIfNotExists(indexFile, indexContent, 'module file');
+
+const testContent = `import { describe, expect, it, vi } from 'vitest';
+
+import ${camelCase(verbletName)} 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('${sentenceCase(verbletName)} verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await ${camelCase(verbletName)}(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+    });
+  });
+});
+`;
+createFileIfNotExists(testFile, testContent, 'test');
+
+const exampleContent = `import { describe, expect, it, vi } from 'vitest';
+
+import ${camelCase(verbletName)} from './index.js';
+
+const examples = [
+  {
+    inputs: { text: 'test' },
+    want: { result: true }
+  }
+];
+
+describe('${sentenceCase(verbletName)} verblet', () => {
+  examples.forEach((example) => {
+    it(example.inputs.text, async () => {
+      const result = await ${camelCase(verbletName)}(example.inputs.text)
+
+      if (example.want.typeOfResult) {
+        expect(typeof result)
+          .toStrictEqual(example.want.typeOfResult);
+      }
+
+      if (example.want.result) {
+        expect(result)
+          .toStrictEqual(example.want.result);
+      }
+    });
+  });
+});
+`;
+createFileIfNotExists(exampleFile, exampleContent, 'example');
+
+console.error(`Created new verblet: ${verbletName}`);

package/scripts/run.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+script_name="$1"
+if [[ "$script_name" =~ ^[a-zA-Z0-9_-]+$ ]]; then
+    script_path="./scripts/$script_name/index.js"
+    if [[ -f "$script_path" ]]; then
+        node "$script_path" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9" "$10"
+    else
+        echo "Script not found: $script_path"
+        exit 1
+    fi
+else
+    echo "Invalid script name: $script_name"
+    exit 1
+fi

package/scripts/runner/index.js

@@ -0,0 +1,30 @@
+
+import chatGPT, {
+  getRedis,
+  list,
+  retry as run,
+  schemas,
+} from '../../src/index.js';
+
+await run(async () => {
+  const results = await chatGPT('make a list of nintendo games with a schema that includes a title, year, and maybe a couple others of your choice', {
+    forceQuery: true,
+    modelOptions: {
+      tools: schemas
+    },
+  });
+
+  const functions = {
+    list: async (listName, options) => {
+      return await list(listName, options);
+    }
+  };
+
+  if (typeof results === 'string') {
+    console.error(results);
+    return
+  }
+  console.error(await functions[results.name](results.arguments.name, results.arguments.options));
+}, { maxRetries: 0 });
+
+await (await getRedis()).disconnect();

package/scripts/simple-editor/README.md

@@ -0,0 +1,34 @@
+# Simple Prompt Editor
+
+This is a simple command-line tool that allows you to interact with the ChatGPT library using your system's default text editor or nano if none is defined.
+
+## Usage
+
+To run the simple ChatGPT editor, use the following command:
+
+```bash
+npm run script -- simple-editor
+```
+
+It will open your system's default text editor or nano if none is defined. The editor allows you to enter your input text, which is then processed by the ChatGPT library. The script performs intent detection to match your request with one of the supported library commands. By default, it does ordinary ChatGPT completion.
+
+
+## Adding Support for New Commands
+
+To add support for new commands, you need to modify the operations array in the provided code. Each command should be an object with the following properties:
+
+ - name: A unique identifier for the command.
+ - parameters: An array of parameter names that the command accepts.
+ - operation: A function that takes an object with the parameters as keys and returns the result of the command.
+
+To add a new command, simply append a new object to the operations array with the required properties. For example, to add a sum command that takes two numbers and returns their sum, you would add the following object:
+
+```javascript
+{
+  name: 'sum',
+  parameters: ['number1', 'number2'],
+  operation: ({ number1, number2 }) => Number(number1) + Number(number2),
+}
+```
+
+After adding the new command, the intent detection function will be able to match the user's input with the new command, and the script will execute the corresponding operation.

package/scripts/simple-editor/index.js

@@ -0,0 +1,68 @@
+import dotenv from 'dotenv/config';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+import chatGPT, { getRedis, auto, bool } from '../../src/index.js';
+import edit from '../../src/lib/editor/index.js';
+import Transcriber from '../../src/lib/transcribe/index.js';
+
+const argv = yargs(hideBin(process.argv))
+  .option('use-intent', {
+    alias: 'i',
+    default: 'true',
+    type: 'string',
+    description: '"false" to disable intent parsing and just use chatGPT',
+  })
+  .option('transcribe', {
+    alias: 't',
+    default: 'false',
+    type: 'string',
+    description: '"true" to enable audio transcription',
+  })
+  .argv;
+
+const operations = [
+  {
+    name: 'bool',
+    fn: ({ text }) => {
+      return bool(text, { forceQuery: true });
+    }
+  },
+];
+
+
+let userInput;
+const useTranscribe = ['true', '1'].includes(argv.transcribe)
+if (useTranscribe) {
+  const transcriber = new Transcriber("stopword"); // Replace "stopword" with the word you want to trigger the stop
+  userInput = await transcriber.startRecording()
+} else {
+  userInput = await edit();
+}
+
+const useIntent = !!['true', '1'].includes(argv.useIntent.toLowerCase())
+
+const commandType = useIntent ? 'Tool selection' : 'Direct ChatGPT';
+console.error(`Command: ${commandType}`);
+const userInputDisplay = userInput.trim().split('\n')
+  .map(line => `| ${line}`)
+  .join('\n');
+
+console.error(userInputDisplay);
+
+let result;
+if (!useIntent) {
+  result = await chatGPT(userInput);
+} else {
+  const intentFound = await auto(userInput, { forceQuery: true });
+
+  const op = operations.find(option => {
+    return option.name === intentFound.name;
+  });
+
+  result = await op.fn(...intentFound.functionArgsAsArray);
+}
+
+console.error(result);
+
+await (await getRedis()).disconnect();

package/scripts/summarize-files/index.js

@@ -0,0 +1,46 @@
+import glob from 'glob';
+import { readFile } from 'fs/promises';
+import SummaryMap from '../../src/chains/summary-map/index.js';
+
+// Define your glob pattern here or pass it as a command line argument
+const globPattern = process.argv[2] || './src/**/*.js';
+
+// Define your target tokens here or pass it as a command line argument
+const targetTokens = process.argv[3] || 4097;
+
+// Initialize the SummaryMap with the target tokens
+const map = new SummaryMap({
+    targetTokens: targetTokens
+});
+
+glob(globPattern, async (err, files) => {
+    if (err) {
+        console.error(err);
+        return;
+    }
+
+    const filePromises = files.map(async (file) => {
+        try {
+            const content = await readFile(file, 'utf8');
+            // Set each file content with its respective filepath as a key
+            map.set(file, {
+                key: file,
+                value: content,
+                weight: 1,
+                type: 'code'
+            });
+        } catch (err) {
+            console.error(`Error reading file ${file}:`, err);
+        }
+    });
+
+    // When all file read operations complete
+    await Promise.all(filePromises);
+    const entries = Array.from(await map.entries());
+
+    // Loop over each key/value and print it to stdout
+    for (const [key, value] of entries) {
+        console.log(`## ${key}\n`);
+        console.log(`\`\`\`js\n${value}\n\`\`\``);
+    }
+});