@far-world-labs/verblets 0.1.1 → 0.1.3

package/src/lib/search-best-first/city-walk.spec.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import searchBestFirst from './index.js';
+
+describe('searchBestFirst city walk example', () => {
+  it('plans a path across the city', async () => {
+    const graph = {
+      start: ['museum', 'park'],
+      museum: ['cafe', 'gallery'],
+      park: ['cafe', 'river'],
+      cafe: ['theater'],
+      gallery: ['theater'],
+      river: ['theater'],
+      theater: ['finish'],
+      finish: [],
+    };
+
+    const next = ({ node }) => graph[node] || [];
+
+    const rank = ({ nodes }) => [...nodes].sort(() => 0.5 - Math.random());
+
+    const visit = ({ node, state }) => ({ ...state, path: [...(state.path || []), node] });
+
+    const { path } = await searchBestFirst({
+      node: 'start',
+      next,
+      rank,
+      visit,
+      goal: ({ node }) => node === 'finish',
+      state: {},
+      returnPath: true,
+    });
+
+    expect(path.length).toBeGreaterThan(2);
+    expect(path[0]).toBe('start');
+    expect(path[path.length - 1]).toBe('finish');
+  });
+});

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

@@ -4,6 +4,10 @@ const hasOwnToString = (obj) => {
   return obj.toString !== Object.prototype.toString;
 };
 
+const keyFor = (obj) => {
+  return hasOwnToString(obj) ? obj.toString() : obj;
+};
+
 const visitDefault = () => {
   return Promise.reject(new Error('Not Implemented'));
 };
@@ -17,9 +21,7 @@ const rankDefault = () => {
 };
 
 const filterWith = (state) => (nextNode) => {
-  return !state.visited.has(
-    hasOwnToString(nextNode) ? nextNode.toString() : nextNode
-  );
+  return !state.visited.has(keyFor(nextNode));
 };
 
 export default async ({
@@ -28,39 +30,68 @@ export default async ({
   rank = rankDefault,
   state: stateInitial = {},
   visit = visitDefault,
+  goal = () => false,
+  returnPath = false,
 }) => {
   let nodesTodo = [rootNode];
+  const parents = new Map();
   let state = stateInitial;
   if (!state.visited) {
     state.visited = new Set();
   }
+  parents.set(keyFor(rootNode), null);
+  let lastNode = rootNode;
 
   while (nodesTodo.length > 0) {
     // eslint-disable-next-line no-await-in-loop
     const nodesRanked = await rank({ nodes: nodesTodo, state });
     const node = nodesRanked.shift();
+    lastNode = node;
 
-    const nodesTodoNext = nodesTodo.filter((el) =>
-      hasOwnToString(node) ? el.toString() !== node.toString() : el !== node
-    );
+    const nodesTodoNext = nodesTodo.filter((el) => keyFor(el) !== keyFor(node));
 
-    state.visited.add(hasOwnToString(node) ? node.toString() : node);
+    state.visited.add(keyFor(node));
 
     // eslint-disable-next-line no-await-in-loop
     state = await visit({ node, state });
 
+    if (goal({ node, state })) {
+      if (returnPath) {
+        const path = [];
+        for (let cur = node; cur !== null; ) {
+          path.unshift(cur);
+          cur = parents.get(keyFor(cur));
+        }
+        return { state, path };
+      }
+      return state;
+    }
+
     // eslint-disable-next-line no-await-in-loop
     const nextNodes = await next({ node, state });
 
+    nextNodes.filter(filterWith(state)).forEach((nextNode) => {
+      const key = keyFor(nextNode);
+      if (!parents.has(key)) {
+        parents.set(key, node);
+      }
+    });
+
     nodesTodo = R.unionWith(
-      (nodeA, nodeB) =>
-        hasOwnToString(nodeA)
-          ? nodeA.toString() === nodeB.toString()
-          : nodeA === nodeB,
+      (nodeA, nodeB) => keyFor(nodeA) === keyFor(nodeB),
       nodesTodoNext,
       nextNodes.filter(filterWith(state))
     );
   }
 
+  if (returnPath) {
+    const path = [];
+    for (let cur = lastNode; cur !== null; ) {
+      path.unshift(cur);
+      cur = parents.get(keyFor(cur));
+    }
+    return { state, path: path.length ? path : null };
+  }
+
   return state;
 };

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import search from './index.js';
+
+describe('search-best-first', () => {
+  it('returns path to goal', async () => {
+    const result = await search({
+      node: 0,
+      next: ({ node }) => [node + 1],
+      rank: ({ nodes }) => nodes,
+      visit: ({ node, state }) => ({ ...state, sum: (state.sum || 0) + node }),
+      goal: ({ node }) => node >= 3,
+      state: {},
+      returnPath: true,
+    });
+
+    expect(result.state.sum).toBe(6); // 0 + 1 + 2 + 3
+    expect(result.path).toEqual([0, 1, 2, 3]);
+  });
+
+  it('handles missing goal', async () => {
+    const result = await search({
+      node: 0,
+      next: ({ node }) => (node < 2 ? [node + 1] : []),
+      rank: ({ nodes }) => nodes,
+      // eslint-disable-next-line no-unused-vars
+      visit: ({ node, state }) => ({ ...state, count: (state.count || 0) + 1 }),
+      goal: ({ node }) => node === 5,
+      state: {},
+      returnPath: true,
+    });
+
+    expect(result.state.count).toBe(3);
+    expect(result.path).toEqual([0, 1, 2]);
+  });
+});

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

@@ -1,6 +1,5 @@
-/* eslint-disable no-await-in-loop */
-import fs from 'node:fs/promises';
-import path from 'node:path';
+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';
@@ -11,54 +10,59 @@ export class Node {
   }
 
   toString() {
-    return `${this.filename}:::${this.functionName ?? ''}`;
+    return `${this.filename}:${this.functionName}`;
   }
 }
 
 const processLocalImport = async (source) => {
-  const importedFile = await fs.readFile(source, 'utf8');
+  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,
-    })
-  );
+  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]
+    // 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 nodeModulePath = `./node_modules/${source}`;
+      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(`${nodeModulePath}/package.json`, 'utf8')
+        await fs.readFile(path.join(nodeModulePath, 'package.json'), 'utf8')
       );
       const mainFilePath = npmPackageJson.main || 'index.js';
-      const importedFile = await fs.readFile(
-        `${nodeModulePath}/${mainFilePath}`,
-        'utf-8'
-      );
+      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: `${nodeModulePath}/${mainFilePath}`,
-          functionName: importKey,
-          functionData: importValue,
-        })
-      );
+      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})`
-    );
+    console.error(`Process npm import [error]: ${error.message} (source: ${source})`);
   }
 
   return [];
@@ -74,9 +78,7 @@ const visitDefault = ({ 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
+    (a, b) => (a.functionName ?? a.filename).length - (b.functionName ?? b.filename).length
   );
 };
 
@@ -84,14 +86,12 @@ 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 functionsFound = Object.entries(parsed.functionsMap).map(([, value]) => {
+    return new Node({
+      ...value,
+      filename: node.filename,
+    });
+  });
 
   const importPromises = Object.values(parsed.importsMap).map((importData) => {
     if (
@@ -99,10 +99,7 @@ const prepareNext = async ({ node, includeNodeModules }) => {
       importData.source.startsWith('../') ||
       importData.source.startsWith('/')
     ) {
-      const resolvedPath = path.resolve(
-        path.dirname(node.filename),
-        importData.source
-      );
+      const resolvedPath = path.resolve(path.dirname(node.filename), importData.source);
 
       return processLocalImport(resolvedPath);
     }

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

@@ -1,5 +1,3 @@
-/* eslint-disable no-await-in-loop */
-
 import path from 'path';
 import fs from 'fs';
 import { parse } from 'acorn';
@@ -26,15 +24,12 @@ const flatten = (obj) => {
   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 Object.entries(flattenedValue).reduce((innerAcc, [innerKey, innerVal]) => {
+        return {
+          ...innerAcc,
+          [innerKey]: (innerAcc[innerKey] ?? 0) + innerVal,
+        };
+      }, acc);
     }
     return acc;
   }, result);
@@ -96,9 +91,7 @@ const parseFiles = (files) => {
             return { ...s.imported }.name; // also has local name
           });
         const source = node.source.value;
-        const importKey = source.startsWith('.')
-          ? convertImport(file, source)
-          : source;
+        const importKey = source.startsWith('.') ? convertImport(file, source) : source;
         importsMap[importKey] = {
           start: node.start,
           end: node.end,
@@ -207,16 +200,12 @@ const parseFiles = (files) => {
         const className = node.id.name;
         node.body.body.forEach((classElement) => {
           if (classElement.type === 'MethodDefinition') {
-            functionsSeen[
-              `${classElement.value.start}:${classElement.value.end}`
-            ] = true;
+            functionsSeen[`${classElement.value.start}:${classElement.value.end}`] = true;
 
-            functionsMap[
-              `MethodDefinition:${className}.${classElement.key.name}`
-            ] = {
+            functionsMap[`MethodDefinition:${className}.${classElement.key.name}`] = {
               start: node.start,
               end: node.end,
-              className: className,
+              className,
               name: classElement.key.name,
               async: classElement.value.async,
               generator: classElement.value.generator,

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

@@ -2,11 +2,7 @@ import modelService from '../../services/llm-model/index.js';
 
 export default (
   text,
-  {
-    minCharsToRemove = 10,
-    model = modelService.getBestAvailableModel(),
-    targetTokenCount,
-  }
+  { minCharsToRemove = 10, model = modelService.getBestPublicModel(), targetTokenCount }
 ) => {
   const ellipsis = '...';
   const textToTokenRatio = text.length / model.toTokens(text).length;
@@ -21,8 +17,7 @@ export default (
     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);
+    trimmedText = trimmedText.slice(0, startIndex) + ellipsis + trimmedText.slice(endIndex);
     tokenCount = model.toTokens(trimmedText).length;
   }
 

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

@@ -59,9 +59,9 @@ describe('Shorten text', () => {
         expect(example.want.end.test(got)).toBe(true);
       }
       if (example.want.maxLength) {
-        expect(
-          modelService.getBestAvailableModel().toTokens(got).length
-        ).toBeLessThanOrEqual(example.want.maxLength);
+        expect(modelService.getBestPublicModel().toTokens(got).length).toBeLessThanOrEqual(
+          example.want.maxLength
+        );
       }
     });
   });

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

@@ -11,18 +11,13 @@ export default (val) => {
 
   const answerPartTrimmed = answerPart.trim() ?? '';
 
-  const answerSection = answerPartTrimmed.length
-    ? answerPart.trim()
-    : questionPart.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();
+  const answerNoQuotes = answerNoPunctuation.replace(/^['"]/, '').replace(/['"]$/, '').trim();
 
   if (answerNoQuotes.startsWith('{') || answerNoQuotes.startsWith('[')) {
     return answerNoQuotes;

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

@@ -0,0 +1,23 @@
+/**
+ * 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

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

package/src/lib/to-date/index.js

@@ -0,0 +1,11 @@
+import stripResponse from '../strip-response/index.js';
+
+export default (val) => {
+  const clean = stripResponse(String(val)).trim();
+  if (clean.toLowerCase() === 'undefined') return undefined;
+  const parsed = new Date(clean);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error('ChatGPT output [error]');
+  }
+  return parsed;
+};

package/src/lib/to-number/index.js

@@ -6,7 +6,7 @@ export default (val) => {
   if (valLower === 'undefined') return undefined;
   const valParsed = +stripNumeric(val);
   if (Number.isNaN(valParsed)) {
-    throw new Error(`ChatGPT output [error]`);
+    throw new Error('ChatGPT output [error]');
   }
   return valParsed;
 };

package/src/lib/transcribe/index.js

@@ -1,8 +1,22 @@
-import whisper from 'whisper-node';
-import record from 'node-record-lpcm16';
+// Lazy import whisper to avoid initialization issues
+let whisper;
+let record;
 
-export default class Transcriber {
+async function getWhisper() {
+  if (!whisper) {
+    whisper = (await import('whisper-node')).default;
+  }
+  return whisper;
+}
 
+async function getRecord() {
+  if (!record) {
+    record = (await import('node-record-lpcm16')).default;
+  }
+  return record;
+}
+
+export default class Transcriber {
   constructor(targetWord, silenceDuration = 5000, wordPauseDuration = 2000) {
     this.targetWord = targetWord;
     this.silenceDuration = silenceDuration;
@@ -12,8 +26,9 @@ export default class Transcriber {
     this.recording = null;
   }
 
-  startRecording() {
-    this.recording = record.record({
+  async startRecording() {
+    const recordModule = await getRecord();
+    this.recording = recordModule.record({
       sampleRateHertz: 16000,
       threshold: 0,
       recordProgram: 'rec',
@@ -30,12 +45,14 @@ export default class Transcriber {
     }
   }
 
-  transcribe(stream) {
-    whisper.transcribeStream(stream, { streaming: true })
-      .then(transcription => {
+  async transcribe(stream) {
+    const whisperModule = await getWhisper();
+    whisperModule
+      .transcribeStream(stream, { streaming: true })
+      .then((transcription) => {
         this.handleTranscription(transcription);
       })
-      .catch(error => {
+      .catch((error) => {
         console.error(error);
       });
   }

package/src/prompts/README.md

@@ -12,4 +12,6 @@ The functions can generate HTML from their inputs and this structure can be tran
 
 # Constants
 
-Currently it's reasonable to keep the text fragments needed for building prompts in a single constants.js file. It's forseable that the number of text fragments will grow. At that point, it would make sense to maintain them with a CMS such as Strapi.
+The text snippets used by many prompt functions are collected in
+[`constants.js`](./constants.js). As the set of fragments grows it may make sense
+to manage them with a CMS such as Strapi.

package/src/prompts/as-object-with-schema.js

@@ -13,15 +13,10 @@ export default (jsonSchema = jsonSchemaDefault) => {
   const propertiesJoined = Object.entries(jsonSchema.properties)
     .map(([key, val]) => {
       const annotations = Object.entries(val).filter(
-        ([annKey, annVal]) =>
-          ['format', 'description'].includes(annKey) && !!annVal
+        ([annKey, annVal]) => ['format', 'description'].includes(annKey) && !!annVal
       );
-      const annotationsFormatted = annotations
-        .map(([k, v]) => `${k}: ${v}`)
-        .join(', ');
-      const annotationsWrapped = annotations.length
-        ? ` (${annotationsFormatted})`
-        : '';
+      const annotationsFormatted = annotations.map(([k, v]) => `${k}: ${v}`).join(', ');
+      const annotationsWrapped = annotations.length ? ` (${annotationsFormatted})` : '';
       return `"${key}": "<${val.type ?? ''}${annotationsWrapped}>"`;
     })
     .join(', ');

package/src/prompts/as-schema-org-text.js

@@ -1,17 +1,25 @@
-import { onlyJSON } from './constants.js';
+import { contentIsSchema, onlyJSON } from './constants.js';
 import asSchemaOrgType from './as-schema-org-type.js';
+import wrapVariable from './wrap-variable.js';
 
 const ensureNumbers = 'ensure values meant to be numbers are numbers';
 const ensureSchemaOrgType = 'ensure the type is a real schema.org type';
 const ensureProperties = 'ensure the returned object has @context, name';
 
-export default (object, type) => {
+export default (object, type, schema) => {
   const typeText = `${asSchemaOrgType(type)}`;
+  const schemaText = schema
+    ? `\n${contentIsSchema} ${wrapVariable(JSON.stringify(schema), {
+        tag: 'schema',
+      })}`
+    : '';
+
   return `Give me "${object}" in schema.org JSON format with a full set of properties. ${
     typeText ? `${typeText}.` : ''
   }
 - ${ensureNumbers}
 - ${ensureSchemaOrgType}
 - ${ensureProperties}
+${schemaText}
 ${onlyJSON}`;
 };

package/src/prompts/code-features.js

@@ -1,8 +1,4 @@
-import {
-  asJSON,
-  explainAndSeparate,
-  explainAndSeparateJSON,
-} from './constants.js';
+import { asJSON, explainAndSeparate, explainAndSeparateJSON } from './constants.js';
 
 export default ({ text, schema }) => {
   return `Analyze the following code to provide scores for each of the features described below.