@far-world-labs/verblets 0.2.0 → 0.3.2

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

@@ -1,22 +0,0 @@
-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

@@ -1,155 +0,0 @@
-import fs from 'fs/promises';
-import path from '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, 'utf-8');
-  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 {
-    // Find the project root by looking for package.json
-    let currentDir = process.cwd();
-    let packageJsonPath = path.join(currentDir, 'package.json');
-
-    // If not found in current directory, try to find it in parent directories
-    while (
-      !(await fs
-        .access(packageJsonPath)
-        .then(() => true)
-        .catch(() => false))
-    ) {
-      const parentDir = path.dirname(currentDir);
-      if (parentDir === currentDir) break; // Reached filesystem root
-      currentDir = parentDir;
-      packageJsonPath = path.join(currentDir, 'package.json');
-    }
-
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-    if (packageJson.dependencies[source] || packageJson.devDependencies[source]) {
-      const nodeModulePath = path.join(currentDir, 'node_modules', source);
-      const npmPackageJson = JSON.parse(
-        await fs.readFile(path.join(nodeModulePath, 'package.json'), 'utf8')
-      );
-      const mainFilePath = npmPackageJson.main || 'index.js';
-      const importedFile = await fs.readFile(path.join(nodeModulePath, mainFilePath), 'utf-8');
-      const parsedImport = parseJSParts(mainFilePath, importedFile);
-
-      return Object.entries(parsedImport.functionsMap).map(([importKey, importValue]) => ({
-        filename: path.join(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

@@ -1,34 +0,0 @@
-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);
-      }
-    });
-  });
-});

package/src/lib/search-js-files/scan-file.js

@@ -1,242 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { parse } from 'acorn';
-import * as walk from 'acorn-walk';
-import dependencyTree from 'dependency-tree';
-
-const stripRootDir = (pathStr, root = process.cwd()) => {
-  return pathStr.replace(new RegExp(`^${root}`), '');
-};
-
-const convertImport = (filePath, importPath) => {
-  return stripRootDir(path.resolve(path.dirname(filePath), importPath));
-};
-
-const flatten = (obj) => {
-  let result = Object.keys(obj).reduce(
-    (memo, key) => ({
-      ...memo,
-      [key]: 1,
-    }),
-    {}
-  );
-
-  result = Object.keys(obj).reduce((acc, key) => {
-    if (typeof obj[key] === 'object') {
-      const flattenedValue = flatten(obj[key]);
-      return Object.entries(flattenedValue).reduce((innerAcc, [innerKey, innerVal]) => {
-        return {
-          ...innerAcc,
-          [innerKey]: (innerAcc[innerKey] ?? 0) + innerVal,
-        };
-      }, acc);
-    }
-    return acc;
-  }, result);
-
-  return result;
-};
-
-const listFiles = (file, cwd) => {
-  const config = {
-    filename: file,
-    directory: cwd,
-    nodeModulesConfig: { entry: 'module' },
-    nonExistent: [],
-    filter: (p) => p.indexOf('node_modules') === -1,
-  };
-
-  return dependencyTree(config);
-};
-
-const parseFiles = (files) => {
-  const filesMap = {};
-  for (const file of files) {
-    const functionsMap = {};
-    const functionsSeen = {};
-    const variablesMap = {};
-    const importsMap = {};
-
-    const code = fs.readFileSync(file, 'utf-8');
-
-    const comments = [];
-
-    const ast = parse(code, {
-      sourceType: 'module',
-      ecmaVersion: 'latest',
-      onComment: comments,
-    });
-
-    const commentsMap = comments.reduce((acc, comment) => {
-      return { ...acc, [comment.start]: comment };
-    }, {});
-
-    filesMap[stripRootDir(file)] = {
-      functionsMap,
-      variablesMap,
-      importsMap,
-      commentsMap,
-    };
-
-    walk.simple(ast, {
-      ImportDeclaration(node) {
-        const declaration = node.specifiers
-          .filter((s) => s.type === 'ImportDefaultSpecifier')
-          .map((s) => {
-            return s.local.name;
-          })?.[0];
-        const specifiers = node.specifiers
-          .filter((s) => s.type === 'ImportSpecifier')
-          .map((s) => {
-            return { ...s.imported }.name; // also has local name
-          });
-        const source = node.source.value;
-        const importKey = source.startsWith('.') ? convertImport(file, source) : source;
-        importsMap[importKey] = {
-          start: node.start,
-          end: node.end,
-          declaration,
-          specifiers,
-          source,
-        };
-      },
-
-      FunctionDeclaration(node) {
-        functionsMap[`${node.type}:${node.id.name}`] = {
-          start: node.start,
-          end: node.end,
-          name: node.id.name,
-          type: node.type,
-          async: node.async,
-          generator: node.generator,
-        };
-      },
-
-      VariableDeclaration(node) {
-        const arrowDeclarations = node.declarations.filter((d) => {
-          return (
-            d.id.type === 'Identifier' &&
-            d.init?.type === 'ArrowFunctionExpression' &&
-            d.init?.body.type === 'BlockStatement'
-          );
-        });
-
-        arrowDeclarations.forEach((d) => {
-          functionsSeen[`${d.init.start}:${d.init.end}`] = true;
-
-          functionsMap[`ArrowFunctionExpression:${d.id.name}`] = {
-            start: d.start,
-            end: d.end,
-            name: d.id.name,
-            async: d.init.async,
-            generator: d.init.generator,
-            type: 'ArrowFunctionExpression',
-          };
-        });
-
-        const fnExpDeclarations = node.declarations.filter((d) => {
-          return (
-            d.id.type === 'Identifier' &&
-            d.init?.type === 'FunctionExpression' &&
-            d.init?.body.type === 'BlockStatement'
-          );
-        });
-
-        fnExpDeclarations.forEach((d) => {
-          functionsSeen[`${d.init.start}:${d.init.end}`] = true;
-
-          functionsMap[`FunctionExpression:${d.id.name}`] = {
-            start: d.start,
-            end: d.end,
-            name: d.id.name,
-            async: d.init.async,
-            generator: d.init.generator,
-            type: 'FunctionExpression',
-          };
-        });
-      },
-
-      // Property Assignment
-      AssignmentExpression(node) {
-        if (
-          (node.right.type === 'FunctionExpression' ||
-            node.right.type === 'ArrowFunctionExpression') &&
-          node.value
-        ) {
-          functionsSeen[`${node.right.start}:${node.right.end}`] = true;
-
-          functionsMap[`${node.value.type}:${node.left.property.name}`] = {
-            start: node.start,
-            end: node.end,
-            name: node.left.property.name,
-            async: node.right.async,
-            generator: node.right.generator,
-            type: node.right.type,
-          };
-        }
-      },
-
-      // Object Definition
-      Property(node) {
-        if (
-          node.value.type === 'FunctionExpression' ||
-          node.value.type === 'ArrowFunctionExpression'
-        ) {
-          functionsSeen[`${node.value.start}:${node.value.end}`] = true;
-
-          functionsMap[`Property:${node.key.name}`] = {
-            start: node.start,
-            end: node.end,
-            name: node.key.name,
-            async: node.value.async,
-            generator: node.value.generator,
-            type: node.value.type,
-          };
-        }
-      },
-
-      // Class Definition
-      ClassDeclaration(node) {
-        const className = node.id.name;
-        node.body.body.forEach((classElement) => {
-          if (classElement.type === 'MethodDefinition') {
-            functionsSeen[`${classElement.value.start}:${classElement.value.end}`] = true;
-
-            functionsMap[`MethodDefinition:${className}.${classElement.key.name}`] = {
-              start: node.start,
-              end: node.end,
-              className,
-              name: classElement.key.name,
-              async: classElement.value.async,
-              generator: classElement.value.generator,
-              type: 'MethodDefinition',
-            };
-          }
-        });
-      },
-    });
-
-    walk.simple(ast, {
-      FunctionExpression(node) {
-        if (!functionsSeen[`${node.start}:${node.end}`]) {
-          functionsMap[`${node.type}:${node.start}`] = {
-            start: node.start,
-            end: node.end,
-            type: node.type,
-            async: node.async,
-            generator: node.generator,
-          };
-        }
-      },
-    });
-  }
-
-  return filesMap;
-};
-
-export default (entryFile) => {
-  const filesTree = listFiles(entryFile, process.cwd());
-  const filesList = Object.keys(flatten(filesTree));
-  const results = parseFiles(filesList);
-  return results;
-};

package/src/lib/shorten-text/index.js

@@ -1,25 +0,0 @@
-import modelService from '../../services/llm-model/index.js';
-
-export default (
-  text,
-  { minCharsToRemove = 10, model = modelService.getBestPublicModel(), targetTokenCount }
-) => {
-  const ellipsis = '...';
-  const textToTokenRatio = text.length / model.toTokens(text).length;
-  let trimmedText = text;
-  let tokenCount = model.toTokens(trimmedText).length;
-
-  while (tokenCount > targetTokenCount) {
-    const charsToRemove = Math.max(
-      Math.ceil((tokenCount - targetTokenCount) * textToTokenRatio),
-      minCharsToRemove
-    );
-    const middleIndex = Math.floor(trimmedText.length / 2);
-    const startIndex = middleIndex - Math.ceil(charsToRemove / 2);
-    const endIndex = middleIndex + Math.floor(charsToRemove / 2);
-    trimmedText = trimmedText.slice(0, startIndex) + ellipsis + trimmedText.slice(endIndex);
-    tokenCount = model.toTokens(trimmedText).length;
-  }
-
-  return trimmedText;
-};

package/src/lib/shorten-text/index.spec.js

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import modelService from '../../services/llm-model/index.js';
-
-import shortenText from './index.js';
-
-const examples = [
-  {
-    name: 'Basic usage',
-    inputs: {
-      text: 'Hello, world! This is a long text for testing the shortenText function.',
-      targetTokenCount: 10,
-    },
-    want: {
-      start: /^Hello, world!/,
-      end: /Text function\.$/,
-      maxLength: 40,
-    },
-  },
-  {
-    name: 'No trimming needed',
-    inputs: {
-      text: 'This text is short enough.',
-      targetTokenCount: 8,
-    },
-    want: {
-      result: 'This text is short enough.',
-    },
-  },
-  {
-    name: 'Minimum characters removal',
-    inputs: {
-      text: 'This is another test to check the minimum characters removal feature.',
-      targetTokenCount: 6,
-      minCharsToRemove: 5,
-    },
-    want: {
-      start: /^This is/,
-      end: /feature\.$/,
-      maxLength: 25,
-    },
-  },
-];
-
-describe('Shorten text', () => {
-  examples.forEach((example) => {
-    it(example.name, () => {
-      const got = shortenText(example.inputs.text, {
-        targetTokenCount: example.inputs.targetTokenCount,
-        minCharsToRemove: example.inputs.minCharsToRemove,
-      });
-
-      if (example.want.result) {
-        expect(got).toEqual(example.want.result);
-      }
-      if (example.want.start) {
-        expect(example.want.start.test(got)).toBe(true);
-      }
-      if (example.want.start) {
-        expect(example.want.end.test(got)).toBe(true);
-      }
-      if (example.want.maxLength) {
-        expect(modelService.getBestPublicModel().toTokens(got).length).toBeLessThanOrEqual(
-          example.want.maxLength
-        );
-      }
-    });
-  });
-});

package/src/lib/strip-numeric/index.js

@@ -1,5 +0,0 @@
-export default (val) => {
-  const noAnswer = val.replace(/[aA]nswer:?/, '').trim();
-  const onlyNumberParts = noAnswer.replace(/[^0-9.]/g, '').trim();
-  return onlyNumberParts;
-};

package/src/lib/strip-response/index.js

@@ -1,30 +0,0 @@
-/*
- * This regex pattern looks for combinations of:
- *
- *   { followed by optional whitespace and ",
- *   [ followed by optional whitespace, {, ", a digit [0-9], or [.
- */
-const jsonStartRegex = /(?:\s*[{[]|[{[]+\s*[{[])/;
-
-export default (val) => {
-  const [questionPart = '', , answerPart = ''] = val.split(/(=){11,29}/);
-
-  const answerPartTrimmed = answerPart.trim() ?? '';
-
-  const answerSection = answerPartTrimmed.length ? answerPart.trim() : questionPart.trim();
-
-  const answerNoPrefix = answerSection.replace(/[aA]nswer:?/, '').trim();
-
-  const answerNoPunctuation = answerNoPrefix.replace(/[., ]+$/g, '').trim();
-
-  const answerNoQuotes = answerNoPunctuation.replace(/^['"]/, '').replace(/['"]$/, '').trim();
-
-  if (answerNoQuotes.startsWith('{') || answerNoQuotes.startsWith('[')) {
-    return answerNoQuotes;
-  }
-
-  const match = answerNoQuotes.match(jsonStartRegex);
-  const answerJSONStart = match ? answerNoQuotes.slice(match.index) : undefined;
-
-  return answerJSONStart ?? answerNoQuotes;
-};

package/src/lib/template-replace/index.js

@@ -1,23 +0,0 @@
-/**
- * Simple template replacement utility
- * Replaces {key} placeholders with values from data object
- *
- * @param {string} template - Template string with {key} placeholders
- * @param {object} data - Data object with key-value pairs
- * @returns {string} - Template with placeholders replaced
- */
-export default function templateReplace(template, data) {
-  if (!template || typeof template !== 'string') {
-    return template || '';
-  }
-
-  if (data === undefined || data === null || typeof data !== 'object') {
-    return template;
-  }
-
-  // Replace all {key} placeholders
-  return template.replace(/\{([^}]+)\}/g, (match, key) => {
-    const value = data[key];
-    return String(value != null ? value : '');
-  });
-}

package/src/lib/template-replace/index.spec.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import templateReplace from './index.js';
-
-describe('templateReplace', () => {
-  it('replaces single placeholder', () => {
-    const result = templateReplace('Hello {name}!', { name: 'World' });
-    expect(result).toBe('Hello World!');
-  });
-
-  it('replaces multiple placeholders', () => {
-    const result = templateReplace('Hello {name}, you are {age} years old', {
-      name: 'John',
-      age: 30,
-    });
-    expect(result).toBe('Hello John, you are 30 years old');
-  });
-
-  it('replaces multiple instances of same placeholder', () => {
-    const result = templateReplace('{name} said "{name} is great"', { name: 'Alice' });
-    expect(result).toBe('Alice said "Alice is great"');
-  });
-
-  it('handles missing data gracefully', () => {
-    const result = templateReplace('Hello {name}!', {});
-    expect(result).toBe('Hello !');
-  });
-
-  it('handles null/undefined values', () => {
-    const result = templateReplace('Value: {value}', { value: null });
-    expect(result).toBe('Value: ');
-  });
-
-  it('handles non-string values', () => {
-    const result = templateReplace('Count: {count}, Active: {active}', {
-      count: 42,
-      active: true,
-    });
-    expect(result).toBe('Count: 42, Active: true');
-  });
-
-  it('returns original template when no data provided', () => {
-    const result = templateReplace('Hello {name}!');
-    expect(result).toBe('Hello {name}!');
-  });
-
-  it('returns original template when data is not an object', () => {
-    const result = templateReplace('Hello {name}!', 'not an object');
-    expect(result).toBe('Hello {name}!');
-  });
-
-  it('handles empty template', () => {
-    const result = templateReplace('', { name: 'test' });
-    expect(result).toBe('');
-  });
-
-  it('handles template with no placeholders', () => {
-    const result = templateReplace('Just plain text', { name: 'test' });
-    expect(result).toBe('Just plain text');
-  });
-});