@far-world-labs/verblets 0.1.2 → 0.1.3

package/.github/workflows/ci.yml

@@ -93,6 +93,9 @@ jobs:
     runs-on: ubuntu-latest
     needs: build
     if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
       - uses: actions/checkout@v4
         with:

package/README.md

@@ -108,76 +108,75 @@ Codebase utilities analyze, test, and improve code quality using AI reasoning. T
 This example shows how verblets enable building systems that understand context, make nuanced decisions, and adapt to complex real-world scenarios - capabilities that would be nearly impossible with traditional programming approaches.
 
 ```javascript
+import bulkMap from './src/chains/bulk-map/index.js';
+import list from './src/chains/list/index.js';
 import {
-  intent,
-  sentiment,
+  anonymize,
   bool,
   enum,
-  toObject,
-  anonymize,
+  intent,
+  listFilter,
   questions,
   sort,
-  listFilter,
-  summaryMap,
+  toObject,
+  sentiment,
+  bulkScore
 } from 'verblets';
 
 // Intelligent customer support system that handles complex, contextual requests
-async function handleCustomerRequest(customerMessage, customerHistory, productCatalog) {
-  // 1. Understand what the customer actually wants
+async function handleCustomerRequest(message, history, catalog) {
   const customerIntent = await intent({
-    text: customerMessage,
+    text: message,
     operations: [
       { name: 'refund-request', parameters: { reason: 'string', orderNumber: 'string?' } },
       { name: 'product-inquiry', parameters: { productType: 'string', feature: 'string?' } },
       { name: 'technical-support', parameters: { issue: 'string', urgency: 'string' } },
-      { name: 'complaint', parameters: { category: 'string', severity: 'string' } },
-    ],
+      { name: 'complaint', parameters: { category: 'string', severity: 'string' } }
+    ]
   });
 
-  // 2. Assess emotional state and urgency
-  const emotionalState = await sentiment(customerMessage);
-  const isUrgent = await bool(`Is this customer request urgent? ${customerMessage}`);
+  const emotion = await sentiment(message);
+  const urgent = await bool(`Is this urgent? ${message}`);
 
-  // 3. Determine appropriate response strategy
-  const responseStrategy = await enum(customerMessage, {
+  const strategy = await enum(message, {
     immediate_escalation: 'Customer is very upset, escalate to human agent',
     detailed_help: 'Customer needs comprehensive assistance',
     quick_resolution: 'Simple issue that can be resolved quickly',
-    educational: 'Customer needs to understand how something works',
+    educational: 'Customer needs to understand how something works'
   });
 
-  // 4. Generate contextual follow-up questions
-  const clarifyingQuestions = await questions(
-    `Customer says: "${customerMessage}". What should we ask to help them better?`
+  const followUpQuestions = await questions(
+    `Customer says: "${message}". What should we ask to help them better?`
   );
 
-  // 5. Find relevant products/solutions from catalog
-  const relevantProducts = await listFilter(
-    productCatalog,
+  const candidates = await listFilter(
+    catalog,
     `Products that might solve: ${
       customerIntent.parameters.issue || customerIntent.parameters.productType
     }`
   );
 
-  // 6. Prioritize solutions by customer context
-  const prioritizedSolutions = await sort(
-    relevantProducts,
-    `by relevance to ${emotionalState} customer with ${customerIntent.intent.operation} request`
+  const scores = await bulkScore(candidates, 'resolution likelihood');
+  const prioritized = await sort(candidates, `by likelihood score ${scores.join(', ')}`);
+
+  const bulletPoints = await bulkMap(
+    prioritized.map(p => p.name),
+    'Write a friendly one-line apology referencing <list>.'
   );
 
-  // 7. Create anonymized case summary for training
+  const sampleReplies = await list('3 reassuring follow-up messages for this customer');
+
   const caseSummary = await anonymize(
-    `Customer ${customerIntent.intent.operation}: ${customerMessage}. 
-     History: ${customerHistory}. Resolution: ${prioritizedSolutions[0]}`
+    `Customer ${customerIntent.intent.operation}: ${message}.
+     History: ${history}. Resolution: ${prioritized[0]}`
   );
 
-  // 8. Structure the complete response
   const response = await toObject(
     `
     Customer needs ${customerIntent.intent.operation} help.
-    They are ${emotionalState} and ${isUrgent ? 'urgent' : 'not urgent'}.
-    Best approach: ${responseStrategy}.
-    Top solution: ${prioritizedSolutions[0]?.name}
+    They are ${emotion} and ${urgent ? 'urgent' : 'not urgent'}.
+    Best approach: ${strategy}.
+    Top solution: ${prioritized[0]?.name}
   `,
     {
       type: 'object',
@@ -187,15 +186,18 @@ async function handleCustomerRequest(customerMessage, customerHistory, productCa
         emotion: { type: 'string' },
         strategy: { type: 'string' },
         recommendedSolution: { type: 'string' },
-        followUpQuestions: { type: 'array' },
-      },
+        followUpQuestions: { type: 'array' }
+      }
     }
   );
 
+
   return {
     ...response,
-    followUpQuestions: clarifyingQuestions.slice(0, 3),
+    followUpQuestions: followUpQuestions.slice(0, 3),
     anonymizedCase: caseSummary,
+    bulletPoints,
+    sampleReplies
   };
 }
 
@@ -207,26 +209,28 @@ const result = await handleCustomerRequest(
     {
       name: 'Premium Wireless Headphones',
       category: 'audio',
-      features: ['noise-canceling', 'wireless'],
+      features: ['noise-canceling', 'wireless']
     },
     { name: 'Express Shipping Upgrade', category: 'service', features: ['priority', 'tracking'] },
-    { name: 'Gift Card', category: 'compensation', features: ['flexible', 'immediate'] },
+    { name: 'Gift Card', category: 'compensation', features: ['flexible', 'immediate'] }
   ]
 );
 
 /* Returns something like:
 {
-  intent: "refund-request", 
+  intent: "refund-request",
   urgency: "high",
   emotion: "frustrated",
   strategy: "immediate_escalation",
   recommendedSolution: "Express Shipping Upgrade",
   followUpQuestions: [
     "What's your order number so I can track this immediately?",
-    "Would you like us to expedite a replacement for tomorrow delivery?", 
+    "Would you like us to expedite a replacement for tomorrow delivery?",
     "How can we make this right for your daughter's birthday?"
   ],
   anonymizedCase: "Customer refund-request: Customer frustrated about delayed premium headphones order for child's birthday..."
+  bulletPoints: ["Apologies for the delay on Premium Wireless Headphones", ...],
+  sampleReplies: ["We're monitoring shipping updates...", ...]
 }
 */
 ```
@@ -240,427 +244,6 @@ This system demonstrates capabilities that would require thousands of lines of t
 - **Privacy-aware data handling** for compliance
 - **Structured output** that integrates with existing systems
 
-<<<<<<< HEAD
-With verblets, complex AI-powered workflows become as simple as calling functions.
-=======
-- **list** - Generate contextual lists
-  ```javascript
-  await list("potential failure points in our microservices architecture");
-  ```
-
-- **intent** - Understand user intentions and extract structured data
-  ```javascript
-  // Define what operations your system can handle
-  const operations = [
-    {
-      name: "book-flight",
-      parameters: {
-        destination: "string",
-        date: "string",
-        class: "string"
-      }
-    },
-    {
-      name: "find-song",
-      parameters: {
-        lyrics: "string",
-        artist: "string?"
-      }
-    }
-  ];
-
-  // It understands flight booking requests
-  const flightRequest = await intent({
-    text: "I need a business class flight to Tokyo next Friday",
-    operations
-  });
-  /* Returns:
-  {
-    "queryText": "I need a business class flight to Tokyo next Friday",
-    "intent": {
-      "operation": "book-flight",
-      "displayName": "Book Flight"
-    },
-    "parameters": {
-      "destination": "Tokyo",
-      "date": "next Friday",
-      "class": "business"
-    }
-  }
-  */
-
-- **auto** - Use function calling to select and prepare operations
-  ```javascript
-  // First, we have our available functions defined as schemas
-  const availableFunctions = [
-    {
-      "name": "bool",
-      "description": "Answer yes/no questions about facts or situations",
-      "parameters": {
-        "type": "object",
-        "properties": {
-          "text": {
-            "type": "string",
-            "description": "The question to answer"
-          }
-        }
-      }
-    },
-    {
-      "name": "list",
-      "description": "Generate lists of relevant items",
-      "parameters": {
-        "type": "object",
-        "properties": {
-          "text": {
-            "type": "string",
-            "description": "What to list"
-          }
-        }
-      }
-    },
-    // ... many more function definitions ...
-  ];
-
-  // When someone has an urgent question
-  const result = await auto(
-    "Help! My dog just ate an avocado! Is this dangerous?"
-  );
-  /* First, auto selects the appropriate function:
-  {
-    "name": "bool",  // Recognizes this needs a yes/no answer
-    "arguments": {
-      "text": "Help! My dog just ate an avocado! Is this dangerous?"
-    },
-    "functionArgsAsArray": [
-      {
-        "text": "Help! My dog just ate an avocado! Is this dangerous?"
-      }
-    ]
-  }
-  */
-
-  // Then it automatically runs the selected function internally, passing arguments it extracts
-  const answer = await bool(result.arguments.text);
-  // Returns: true (yes, it can be dangerous)
-  ```
-
-- **questions** - Explore topics through intelligent question generation
-  ```javascript
-
-  const investigation = await questions(
-    "Why isn't my houseplant thriving?",
-    {
-      searchBreadth: 0.7,  // Explore more broadly (0-1)
-      shouldStop: (q, all) => all.length > 20  // Custom stopping condition
-    }
-  );
-  /* Returns targeted diagnostic questions:
-  [
-    "Which direction does the window face?",
-    "Are the leaves turning yellow or brown?",
-    "Is the soil staying wet for long periods?",
-    "Are there any visible pests on the leaves?",
-    "When was it last repotted?",
-    "Is there good drainage in the pot?",
-    "What's the humidity level in the room?",
-    // ... continues until stopping condition ...
-  ]
-  */
-  ```
-
-- **shorten-text** - Intelligently compress text while preserving meaning
-  ```javascript
-  // Shorten long content while keeping key information
-  const story = `Once upon a time, in a bustling city called Metropolis, 
-    there lived a young programmer named Ada. She spent her days writing 
-    elegant code and her nights dreaming of artificial intelligence. 
-    One day, while debugging a particularly tricky neural network, 
-    she discovered something extraordinary...`;
-
-  const shortened = await shortenText(story, {
-    targetTokenCount: 20,
-    minCharsToRemove: 15
-  });
-  /* Returns:
-     "Once upon a time, in Metropolis, a programmer named Ada 
-      spent her days writing code... discovered something extraordinary"
-  */
-
-  // Preserve structure while reducing size
-  const documentation = `# API Reference
-    ## Authentication
-    All requests must include an API key in the header.
-    The key should be prefixed with 'Bearer '.
-    
-    ## Rate Limiting
-    Requests are limited to 100 per minute.
-    Exceeding this will result in a 429 response.
-    
-    ## Endpoints
-    GET /users - Retrieve user list
-    POST /users - Create new user
-    DELETE /users/{id} - Remove user`;
-
-  const compact = await shortenText(documentation, {
-    targetTokenCount: 30,
-    minCharsToRemove: 20
-  });
-  /* Returns:
-     "# API Reference
-      ## Authentication
-      All requests need API key... 'Bearer '
-      
-      ## Rate Limiting
-      100 per minute... 429 response
-      
-      ## Endpoints
-      GET /users...DELETE /users/{id}"
-  */
-  ```
-
-- **bulk-map** - Map over lists in retryable batches using the `listMap` verblet
-```javascript
-import { bulkMap } from './src/index.js';
-
-  const gadgets = [
-    'solar-powered flashlight',
-    'quantum laptop',
-    'smart refrigerator',
-    // ...more items
-  ];
-  const results = await bulkMap(
-    gadgets,
-    'Give each item a catchphrase worthy of a blockbuster commercial',
-    { chunkSize: 5, maxAttempts: 2 }
-  );
-  // results[0] === 'Illuminate your world with the sun'
-  // results[1] === 'Computing beyond limits'
-  ```
-
-- **bulk-reduce** - Reduce long lists sequentially using `listReduce`
-```javascript
-  import bulkReduce from './src/chains/bulk-reduce/index.js';
-
-  const logLines = [
-    'User logged in',
-    'User viewed dashboard',
-    'User logged out'
-  ];
-  const summary = await bulkReduce(logLines, 'Summarize the events');
-  // e.g. 'User session: login, dashboard view and logout'
-```
-
-<<<<<<< HEAD
-**bulk-partition** - Discover the best categories and group large lists consistently
-```javascript
-  import bulkPartition from './src/chains/bulk-partition/index.js';
-
-  const feedback = [
-    'Great interface and onboarding',
-    'Price is a bit steep',
-    'Love the mobile app',
-    'Needs more integrations'
-  ];
-  const result = await bulkPartition(
-    feedback,
-    'Is each line praise, criticism, or a feature request?',
-    { chunkSize: 2, topN: 3 }
-  );
-  // {
-  //   praise: ['Great interface and onboarding', 'Love the mobile app'],
-  //   criticism: ['Price is a bit steep'],
-  //   'feature request': ['Needs more integrations']
-  // }
-```
-
-- **themes** - Extract recurring themes from text
-```javascript
-  const mainThemes = await themes(longReport, { topN: 3 });
-  // ['strategy', 'market challenges', 'team morale']
-```
-=======
-- **bulk-find** - Search lists in batches using `listFind`
-  ```javascript
-  import bulkFind, { bulkFindRetry } from './src/lib/bulk-find/index.js';
-
-  const diaryEntries = [
-    'Hiked up the mountains today and saw breathtaking views',
-    'Visited the local market and tried a spicy stew',
-    'Spotted penguins playing on the beach this morning'
-  ];
-  const match = await bulkFindRetry(diaryEntries, 'mentions penguins', {
-    chunkSize: 2,
-    maxAttempts: 2
-  });
-  // => 'Spotted penguins playing on the beach this morning'
-  ```
-
->>>>>>> f71abac (Restore eslint disable comment)
-- **search-best-first** - Intelligently explore solution spaces
-  ```javascript
-  // Find the best recipe adjustments when ingredients are missing
-  const search = new BestFirstSearch({
-    initialState: {
-      recipe: "Classic Tiramisu",
-      missing: ["mascarpone cheese", "ladyfingers"],
-      available: ["cream cheese", "pound cake", "whipped cream"]
-    },
-    goalTest: state => state.substitutions.complete && state.flavor.preserved,
-    heuristic: state => state.flavor.similarity
-  });
-
-  const path = await search.findPath();
-  /* Returns sequence of steps:
-  [
-    {
-      action: "substitute mascarpone",
-      details: "Mix 8oz cream cheese with 1/4 cup whipped cream",
-      confidence: 0.85
-    },
-    {
-      action: "substitute ladyfingers",
-      details: "Slice pound cake, toast until crisp, soak in coffee",
-      confidence: 0.75
-    },
-    {
-      action: "adjust ratios",
-      details: "Increase coffee soak time to 45 seconds for pound cake",
-      confidence: 0.9
-    }
-  ]
-  */
-
-  // Or find the optimal way to refactor complex code
-  const refactorPath = await new BestFirstSearch({
-    initialState: {
-      file: "src/legacy-parser.js",
-      metrics: {
-        complexity: 85,
-        coverage: 0.4,
-        maintainability: "D"
-      }
-    },
-    goalTest: state => 
-      state.metrics.complexity < 30 && 
-      state.metrics.coverage > 0.8 &&
-      state.metrics.maintainability === "A",
-    heuristic: state => 
-      (1 / state.metrics.complexity) * 
-      state.metrics.coverage *
-      (state.metrics.maintainability === "A" ? 1 : 0.5)
-  }).findPath();
-  /* Returns optimal refactoring sequence:
-  [
-    {
-      action: "extract function",
-      target: "parseNestedBlocks()",
-      benefit: "Reduces complexity by 40%"
-    },
-    {
-      action: "add unit tests",
-      coverage: ["error handling", "edge cases"],
-      benefit: "Coverage increases to 85%"
-    },
-    {
-      action: "implement strategy pattern",
-      components: ["BlockParser", "InlineParser"],
-      benefit: "Maintainability improves to grade A"
-    }
-  ]
-  */
-  ```
-
-- **test-advice** - Get comprehensive testing and code quality insights
-  ```javascript
-  // Get deep analysis of your code's test coverage and quality
-  const insights = await testAdvice("src/payment-processor.js");
-  /* Returns array of findings across multiple dimensions:
-  [
-    {
-      "name": "Boundary Testing",
-      "expected": "Handle zero-amount transactions",
-      "saw": "No validation for $0.00 payments in processPayment()",
-      "isSuccess": false
-    },
-    {
-      "name": "Success Scenarios",
-      "expected": "Processes standard credit card payment",
-      "saw": "Correctly handles Visa/MC format: line 47 validateCard()",
-      "isSuccess": true
-    },
-    {
-      "name": "Clean Code",
-      "expected": "Single responsibility in transaction logging",
-      "saw": "logPayment() mixing business logic with logging: line 92",
-      "isSuccess": false
-    },
-    // ... analyzes across 8 dimensions:
-    // - Boundary cases
-    // - Success scenarios
-    // - Failure modes
-    // - Potential defects
-    // - Best practices
-    // - Clean code principles
-    // - Code quality
-    // - Refactoring opportunities
-  ]
-  */
-  ```
-
-- **veiled-variants** - Mask sensitive queries with safer alternatives
-  ```javascript
-  const alternatives = await veiledVariants({
-    prompt: "If pigeons are government spies, how can I ask for counter-surveillance tips without sounding paranoid?"
-  });
-  /* Returns 15 reframed queries */
-  ```
-
-- **scan-js** - Analyze code for quality and maintainability
-  ```javascript
-  // Analyze your codebase for maintainability
-  const analysis = await scanJs({
-    entry: "src/app.js",
-    features: "maintainability"
-  });
-  /* Returns analysis of each function:
-  {
-    "src/app.js:::handlePayment": {
-      "complexity": "low",
-      "documentation": "well-documented",
-      "sideEffects": "isolated to database calls",
-      "errorHandling": "comprehensive",
-      "testability": "high"
-    },
-    "src/app.js:::validateInput": {
-      "complexity": "medium",
-      "documentation": "needs improvement",
-      "sideEffects": "pure function",
-      "errorHandling": "basic validation only",
-      "testability": "high"
-    }
-    // ... continues for all functions ...
-  }
-  */
-
-  // Focus on specific quality aspects
-  const security = await scanJs({
-    entry: "src/auth/",
-    features: "security"
-  });
-  /* Returns security-focused analysis:
-  {
-    "src/auth/login.js:::hashPassword": {
-      "inputValidation": "sanitizes all inputs",
-      "cryptography": "uses current best practices",
-      "dataExposure": "no sensitive data in logs",
-      "authentication": "implements rate limiting"
-    }
-    // ... continues for all security-relevant functions ...
-  }
-  */
-  ```
->>>>>>> 01eb5cf (Add themes chain for dual reduce)
 
 ## Contributing
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@far-world-labs/verblets",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "OpenAI Client",
-  "main": "index.js",
+  "main": "src/index.js",
   "type": "module",
   "repository": {
     "type": "git",

package/src/chains/list/index.spec.js

@@ -1,11 +1,16 @@
 import fs from 'node:fs/promises';
 import { describe, expect, it, vi } from 'vitest';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 
 import toObject from '../../verblets/to-object/index.js';
 import list from './index.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 const loadSchema = async () => {
-  const file = (await fs.readFile('./src/json-schemas/cars-test.json')).toString();
+  const file = (await fs.readFile(join(__dirname, '../../json-schemas/cars-test.json'))).toString();
 
   return toObject(file);
 };

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

@@ -1,5 +1,5 @@
-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';
@@ -10,12 +10,12 @@ 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,
@@ -28,18 +28,35 @@ const processNpmImport = async (source, includeNodeModules = false) => {
   if (!includeNodeModules) return [];
 
   try {
-    const packageJson = JSON.parse(await fs.readFile('./package.json', 'utf8'));
+    // 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 = `./node_modules/${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}`,
+        filename: path.join(nodeModulePath, mainFilePath),
         functionName: importKey,
         functionData: importValue,
       }));

package/src/lib/transcribe/index.js

@@ -1,5 +1,20 @@
-import whisper from 'whisper-node';
-import record from 'node-record-lpcm16';
+// Lazy import whisper to avoid initialization issues
+let whisper;
+let record;
+
+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) {
@@ -11,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',
@@ -29,8 +45,9 @@ export default class Transcriber {
     }
   }
 
-  transcribe(stream) {
-    whisper
+  async transcribe(stream) {
+    const whisperModule = await getWhisper();
+    whisperModule
       .transcribeStream(stream, { streaming: true })
       .then((transcription) => {
         this.handleTranscription(transcription);

package/src/prompts/intent.js

@@ -1,21 +1,20 @@
-import fs from 'node:fs/promises';
-
-import {
-  contentIsExample,
-  contentIsSchema,
-  onlyJSON,
-  contentIsIntent,
-  contentIsOperationOption,
-  contentIsParametersOptions,
-} from './constants.js';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 import wrapVariable from './wrap-variable.js';
+import { onlyJSON } from './constants.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const contentIsIntent = 'The intent is:';
+const contentIsSchema = 'The schema is:';
+const contentIsExample = 'An example of the output is:';
+const contentIsOperationOption = 'The possible operations are:';
+const contentIsParametersOptions = 'The possible parameters are:';
 
 const exampleJSON = `{
-  "queryText": "play some music",
-  "intent": {
-    "operation": "play-music",
-    "displayName": "Play Music"
-  },
+  "intent": "play_music",
   "parameters": {
     "genre": "rock"
   },
@@ -24,7 +23,7 @@ const exampleJSON = `{
   }
 }`;
 
-const intentSchema = JSON.parse(await fs.readFile('./src/json-schemas/intent.json'));
+const intentSchema = JSON.parse(await fs.readFile(join(__dirname, '../json-schemas/intent.json')));
 
 /**
  * Approximates intent recognition like you might find with Wit.ai,

package/src/verblets/intent/index.examples.js

@@ -1,26 +1,31 @@
 import Ajv from 'ajv';
 import fs from 'node:fs/promises';
 import { describe, expect, it, beforeAll, afterAll } from 'vitest';
-
+import { expect as aiExpect } from '../../chains/expect/index.js';
 import { longTestTimeout } from '../../constants/common.js';
-import aiExpect from '../expect/index.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
 import intent from './index.js';
 
-const resultSchema = async () => {
-  return JSON.parse(await fs.readFile('./src/json-schemas/intent.json'));
-};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function getIntentSchema() {
+  return JSON.parse(await fs.readFile(join(__dirname, '../../json-schemas/intent.json')));
+}
 
 const examples = [
   {
     inputs: { text: 'Give me a flight to Burgas' },
-    want: { resultSchema },
+    want: { resultSchema: getIntentSchema },
   },
   {
     inputs: {
       text: 'Lookup a song by the quote \
 "I just gotta tell you how I\'m feeling"',
     },
-    want: { resultSchema },
+    want: { resultSchema: getIntentSchema },
   },
 ];
 
@@ -85,7 +90,7 @@ describe('Intent verblet', () => {
       const result = await intent({ text: travelRequest });
 
       // Traditional schema validation
-      const schema = await resultSchema();
+      const schema = await getIntentSchema();
       const ajv = new Ajv();
       const validate = ajv.compile(schema);
       expect(validate(result)).toBe(true);
@@ -112,7 +117,7 @@ describe('Intent verblet', () => {
       const result = await intent({ text: musicQuery });
 
       // Schema validation
-      const schema = await resultSchema();
+      const schema = await getIntentSchema();
       const ajv = new Ajv();
       const validate = ajv.compile(schema);
       expect(validate(result)).toBe(true);