@far-world-labs/verblets 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,254 @@
+# Verblets
+
+Verblets is a library of AI-powered utilities that transform natural language and structured data into reliable, structured outputs. Each function uses language model intelligence while constraining outputs to limit hallucination and ensure software reliability.
+
+## Repository Guide
+
+### Quick Links
+
+- [Chains](./src/chains/) - AI-powered workflows and operations
+- [Verblets](./src/verblets/) - Core AI utility functions
+- [Library Helpers](./src/lib/) - Utility functions and wrappers
+- [Prompts](./src/prompts/) - Reusable prompt templates
+- [JSON Schemas](./src/json-schemas/) - Data validation schemas
+
+## Verblets
+
+### Primitives
+
+Primitive verblets extract basic data types from natural language with high reliability. They constrain LLM outputs to prevent hallucination while handling the complexity of human expression.
+
+- [bool](./src/verblets/bool) - interpret text as true/false decisions
+- [enum](./src/verblets/enum) - map text to predefined options
+- [number](./src/verblets/number) - extract numeric values from text
+- [number-with-units](./src/verblets/number-with-units) - parse numbers with units and conversions
+- [date](./src/chains/date) - return Date objects from natural language prompts
+
+### Lists
+
+List operations transform, filter, and organize collections using natural language criteria. They handle both small lists with individual verblets and large datasets with batch processing chains.
+
+- [bulk-map](./src/chains/bulk-map) - process long lists in retryable batches
+- [bulk-reduce](./src/chains/bulk-reduce) - reduce long lists in manageable chunks
+- [bulk-find](./src/chains/bulk-find) - locate the best match in large datasets
+- [bulk-group](./src/chains/bulk-group) - group large datasets efficiently
+- [bulk-filter](./src/chains/bulk-filter) - filter huge lists in batches
+- [intersections](./src/chains/intersections) - find comprehensive intersections for all combinations
+- [list](./src/chains/list) - generate contextual lists from prompts
+- [list-map](./src/verblets/list-map) - transform each item in a list
+- [list-reduce](./src/verblets/list-reduce) - combine list items using custom logic
+- [list-find](./src/verblets/list-find) - pick the single best item from a list
+- [list-filter](./src/verblets/list-filter) - filter lists with natural language criteria
+- [list-group](./src/verblets/list-group) - categorize list items into groups
+- [list-expand](./src/verblets/list-expand) - generate additional similar items
+- [intersection](./src/verblets/intersection) - describe common traits between items
+- [sort](./src/chains/sort) - order lists by any describable criteria
+- [bulk-score](./src/chains/bulk-score) - score lists with calibrated examples
+
+### Content
+
+Content utilities generate, transform, and analyze text while maintaining structure and meaning. They excel at creative tasks, system analysis, and privacy-aware text processing.
+
+- [anonymize](./src/chains/anonymize) - scrub personal details from text
+- [collect-terms](./src/chains/collect-terms) - extract difficult vocabulary
+- [dismantle](./src/chains/dismantle) - break systems into components
+- [disambiguate](./src/chains/disambiguate) - resolve ambiguous word meanings using context
+- [filter-ambiguous](./src/chains/filter-ambiguous) - find and rank unclear terms for disambiguation
+- [name](./src/verblets/name) - name something from a definition or description
+- [name-similar-to](./src/verblets/name-similar-to) - suggest short names that match a style
+- [questions](./src/chains/questions) - produce clarifying questions
+- [schema-org](./src/verblets/schema-org) - create schema.org objects
+- [socratic](./src/chains/socratic) - explore assumptions using a Socratic dialogue
+- [summary-map](./src/chains/summary-map) - summarize a collection
+- [themes](./src/chains/themes) - identify themes in text
+- [category-samples](./src/chains/category-samples) - generate diverse examples for any category
+- [to-object](./src/verblets/to-object) - convert descriptions to structured objects
+- [veiled-variants](./src/chains/veiled-variants) - rephrase sensitive queries safely
+
+### Utility Operations
+
+Utility operations provide meta-functionality like automatic tool selection, intent parsing, and context compression. They're essential for building intelligent systems that can adapt and scale.
+
+- [auto](./src/verblets/auto) - automatically select the best verblet for a task
+- [expect](./src/verblets/expect) - simple LLM assertions
+- [expect chain](./src/chains/expect) - assert things about data with LLM reasoning
+- [intent](./src/verblets/intent) - extract user intent and structured parameters
+- [sentiment](./src/verblets/sentiment) - detect emotional tone of text
+- [summary-map](./src/chains/summary-map) - store self-resizing hash table values. Useful for fixed-sized contexts.
+- [set-interval](./src/chains/set-interval) - Conversational scheduler
+
+### Codebase
+
+Codebase utilities analyze, test, and improve code quality using AI reasoning. They provide insights that traditional static analysis tools miss by understanding context and intent.
+
+- [scan-js](./src/chains/scan-js) - analyze JavaScript code quality
+- [test](./src/chains/test) - run AI-driven software tests
+- [test-advice](./src/chains/test-advice) - get feedback on test coverage
+
+## Library Helpers
+
+- [chatgpt](./src/lib/chatgpt) - OpenAI ChatGPT wrapper
+- [prompt-cache](./src/lib/prompt-cache) - cache prompts and responses
+- [retry](./src/lib/retry) - retry asynchronous calls
+- [search-best-first](./src/lib/search-best-first) - best-first search algorithm
+- [search-js-files](./src/lib/search-js-files) - scan JavaScript sources
+- [combinations](./src/lib/combinations) - generate array combinations
+- [shorten-text](./src/lib/shorten-text) - shorten text using a model
+- [strip-numeric](./src/lib/strip-numeric) - remove non-digit characters
+- [strip-response](./src/lib/strip-response) - clean up model responses
+- [to-bool](./src/lib/to-bool) - parse text to boolean
+- [to-enum](./src/lib/to-enum) - parse text to enum values
+- [to-number](./src/lib/to-number) - parse text to numbers
+- [to-number-with-units](./src/lib/to-number-with-units) - parse numbers with units
+- [to-date](./src/lib/to-date) - parse text to JavaScript Date objects
+- [transcribe](./src/lib/transcribe) - microphone transcription via Whisper
+
+## Example: Intelligent Customer Support System
+
+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 {
+  anonymize,
+  bool,
+  enum,
+  intent,
+  listFilter,
+  questions,
+  sort,
+  toObject,
+  sentiment,
+  bulkScore
+} from 'verblets';
+
+// Intelligent customer support system that handles complex, contextual requests
+async function handleCustomerRequest(message, history, catalog) {
+  const customerIntent = await intent({
+    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' } }
+    ]
+  });
+
+  const emotion = await sentiment(message);
+  const urgent = await bool(`Is this urgent? ${message}`);
+
+  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'
+  });
+
+  const followUpQuestions = await questions(
+    `Customer says: "${message}". What should we ask to help them better?`
+  );
+
+  const candidates = await listFilter(
+    catalog,
+    `Products that might solve: ${
+      customerIntent.parameters.issue || customerIntent.parameters.productType
+    }`
+  );
+
+  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>.'
+  );
+
+  const sampleReplies = await list('3 reassuring follow-up messages for this customer');
+
+  const caseSummary = await anonymize(
+    `Customer ${customerIntent.intent.operation}: ${message}.
+     History: ${history}. Resolution: ${prioritized[0]}`
+  );
+
+  const response = await toObject(
+    `
+    Customer needs ${customerIntent.intent.operation} help.
+    They are ${emotion} and ${urgent ? 'urgent' : 'not urgent'}.
+    Best approach: ${strategy}.
+    Top solution: ${prioritized[0]?.name}
+  `,
+    {
+      type: 'object',
+      properties: {
+        intent: { type: 'string' },
+        urgency: { type: 'string' },
+        emotion: { type: 'string' },
+        strategy: { type: 'string' },
+        recommendedSolution: { type: 'string' },
+        followUpQuestions: { type: 'array' }
+      }
+    }
+  );
+
+
+  return {
+    ...response,
+    followUpQuestions: followUpQuestions.slice(0, 3),
+    anonymizedCase: caseSummary,
+    bulletPoints,
+    sampleReplies
+  };
+}
+
+// Usage: Handle a complex customer scenario
+const result = await handleCustomerRequest(
+  "I'm really frustrated! I ordered your premium headphones 2 weeks ago for my daughter's birthday tomorrow and they still haven't arrived. The tracking says 'processing' but I paid for 2-day shipping. This is completely unacceptable and I want my money back immediately!",
+  'Previous orders: 3 successful deliveries, 1 late delivery complaint resolved',
+  [
+    {
+      name: 'Premium Wireless Headphones',
+      category: 'audio',
+      features: ['noise-canceling', 'wireless']
+    },
+    { name: 'Express Shipping Upgrade', category: 'service', features: ['priority', 'tracking'] },
+    { name: 'Gift Card', category: 'compensation', features: ['flexible', 'immediate'] }
+  ]
+);
+
+/* Returns something like:
+{
+  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?",
+    "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...", ...]
+}
+*/
+```
+
+This system demonstrates capabilities that would require thousands of lines of traditional code and extensive machine learning expertise:
+
+- **Contextual understanding** of customer emotions and intent
+- **Dynamic decision making** based on multiple factors
+- **Adaptive questioning** that changes based on the situation
+- **Intelligent prioritization** of solutions
+- **Privacy-aware data handling** for compliance
+- **Structured output** that integrates with existing systems
+
+
+## Contributing
+
+Help us explore what's possible when we rebuild software primitives with intelligence at their core.
+
+## License
+
+All Rights Reserved - Far World Labs

package/eslint.config.js

@@ -0,0 +1,80 @@
+import js from '@eslint/js';
+import prettierConfig from 'eslint-config-prettier';
+import prettierPlugin from 'eslint-plugin-prettier';
+
+export default [
+  js.configs.recommended,
+  {
+    files: ['src/**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        URL: 'readonly',
+        AbortController: 'readonly',
+        fetch: 'readonly',
+        setTimeout: 'readonly',
+        clearTimeout: 'readonly',
+        setInterval: 'readonly',
+        clearInterval: 'readonly',
+        // Vitest
+        beforeEach: 'readonly',
+        afterEach: 'readonly',
+        describe: 'readonly',
+        it: 'readonly',
+        expect: 'readonly',
+        vi: 'readonly',
+      },
+    },
+    linterOptions: {
+      reportUnusedDisableDirectives: false,
+    },
+    plugins: {
+      prettier: prettierPlugin,
+    },
+    rules: {
+      'prettier/prettier': 'error',
+      
+      // TODO: Remove console statements and replace with proper logging
+      'no-console': 'off',
+      
+      // TODO: Refactor await-in-loop patterns to use Promise.all()
+      'no-await-in-loop': 'off',
+
+      // Customize recommended rules
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+
+      // Additional quality rules not in recommended
+      'require-await': 'error',
+      'prefer-arrow-callback': 'error',
+      'prefer-template': 'error',
+      'object-shorthand': 'error',
+      'array-callback-return': 'error',
+
+      // Syntax restrictions
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'ForInStatement',
+          message: 'Use Object.{keys,values,entries} instead of for..in',
+        },
+        {
+          selector: 'WithStatement',
+          message: '`with` is not allowed',
+        },
+      ],
+    },
+  },
+  {
+    files: ['**/*.spec.js', '**/*.test.js'],
+    rules: {
+      'require-await': 'off', // Test functions often don't need await
+    },
+  },
+  prettierConfig,
+]; 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@far-world-labs/verblets",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenAI Client",
-  "main": "index.js",
+  "main": "src/index.js",
   "type": "module",
   "repository": {
     "type": "git",
@@ -15,56 +15,68 @@
     "--": "npm run script -- generate-verblet foo",
     "script": "./scripts/run.sh",
     "test": "vitest",
-    "examples": "EXAMPLES=true vitest --config .vite.config.examples.js",
+    "examples:warn": "source .env && LLM_EXPECT_MODE=info EXAMPLES=true vitest --config .vitest.config.examples.js",
+    "examples": "source .env && LLM_EXPECT_MODE=error EXAMPLES=true vitest --config .vitest.config.examples.js",
     "lint": "eslint 'src/**/*.{js,jsx}'",
     "lint:fix": "eslint 'src/**/*.{js,jsx}' --fix",
+    "check:deps": "npx npm-deprecated-check current",
     "husky:install": "husky install",
     "husky:uninstall": "husky uninstall",
-    "prepare": "npx husky install"
+    "prepare": "npx husky install",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
   },
   "config": {
     "gen-script": "./scripts/run.sh gen-$1"
   },
   "author": "Far World Labs",
   "license": "All Rights Reserved",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "acorn": "^8.8.2",
     "acorn-walk": "^8.2.0",
     "ajv": "^8.12.0",
     "chai": "^4.3.7",
     "change-case": "^4.1.2",
+    "commander": "^11.0.0",
+    "compromise": "^14.14.4",
     "dependency-tree": "^10.0.1",
     "dotenv": "^16.0.3",
     "gpt-tokenizer": "^2.1.2",
     "gpt4-tokenizer": "^1.3.0",
+    "lodash": "^4.17.21",
     "mocha": "^10.2.0",
     "node-fetch": "^3.3.0",
-    "nodemon": "^2.0.22",
+    "node-record-lpcm16": "^1.0.1",
     "ramda": "^0.29.0",
     "redis": "^4.6.5",
     "uuid": "^9.0.0",
-    "vitest": "^0.30.1",
+    "vitest": "^3.1.3",
+    "whisper-node": "^1.1.1",
     "yargs": "^17.7.1"
   },
   "devDependencies": {
+    "@eslint/js": "^9.28.0",
+    "@stylistic/eslint-plugin": "^4.4.0",
     "@types/node": "^18.16.3",
-    "eslint": "^8.39.0",
-    "eslint-config-airbnb": "^19.0.4",
+    "@vitest/ui": "^3.1.3",
+    "eslint": "^9.28.0",
     "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-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.12.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-react": "^7.32.2",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-unicorn": "^59.0.1",
+    "eslint-plugin-vitest": "^0.5.4",
     "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",
+    "nodemon": "^3.1.10",
+    "npm-deprecated-check": "^1.5.0",
     "prettier": "^2.8.8",
-    "release-it": "^15.10.1",
-    "whisper-node": "^1.1.1",
+    "release-it": "^19.0.3",
     "why-is-node-running": "^2.2.2"
   },
   "lint-staged": {

package/scripts/generate-test/index.js

@@ -8,9 +8,35 @@ chatGPT,
   getRedis,
   SummaryMap
 } from '../../src/index.js';
-
-const modulePath = process.argv[2];
-const functionName = process.argv[3];
+import modelService from '../../src/services/llm-model/index.js';
+import { Command } from 'commander';
+
+const program = new Command();
+program
+  .argument('<modulePath>', 'Module to test')
+  .argument('[functionName]', 'Specific function to test')
+  .option('-p, --privacy', 'Use privacy model if configured')
+  .option('-m, --model <modelName>', 'Specify model name to use');
+
+program.parse(process.argv);
+
+const options = program.opts();
+const [modulePath, functionName] = program.args;
+
+if (options.privacy) {
+  try {
+    modelService.setGlobalOverride('modelName', 'privacy');
+  } catch (err) {
+    console.error(`Privacy model error: ${err.message}`);
+  }
+}
+if (options.model) {
+  try {
+    modelService.setGlobalOverride('modelName', options.model);
+  } catch (err) {
+    console.error(`Model override error: ${err.message}`);
+  }
+}
 
 if (!modulePath) {
   console.error('Please specify a module to test.');

package/scripts/runner/index.js

@@ -5,6 +5,32 @@ import chatGPT, {
   retry as run,
   schemas,
 } from '../../src/index.js';
+import modelService from '../../src/services/llm-model/index.js';
+import { Command } from 'commander';
+
+const program = new Command();
+program
+  .option('-p, --privacy', 'Use privacy model if configured')
+  .option('-m, --model <modelName>', 'Specify model name to use');
+
+program.parse(process.argv);
+
+const options = program.opts();
+
+if (options.privacy) {
+  try {
+    modelService.setGlobalOverride('modelName', 'privacy');
+  } catch (err) {
+    console.error(`Privacy model error: ${err.message}`);
+  }
+}
+if (options.model) {
+  try {
+    modelService.setGlobalOverride('modelName', options.model);
+  } catch (err) {
+    console.error(`Model override error: ${err.message}`);
+  }
+}
 
 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', {

package/scripts/simple-editor/index.js

@@ -1,25 +1,36 @@
 import dotenv from 'dotenv/config';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
+import { Command } from 'commander';
 
 import chatGPT, { getRedis, auto, bool } from '../../src/index.js';
+import modelService from '../../src/services/llm-model/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 program = new Command();
+program
+  .option('-t, --transcribe', 'Enable audio transcription')
+  .option('--no-use-intent', 'Disable intent parsing')
+  .option('-p, --privacy', 'Use privacy model if configured')
+  .option('-m, --model <modelName>', 'Specify model name to use');
+
+program.parse(process.argv);
+
+const argv = program.opts();
+
+if (argv.privacy) {
+  try {
+    modelService.setGlobalOverride('modelName', 'privacy');
+  } catch (err) {
+    console.error(`Privacy model error: ${err.message}`);
+  }
+}
+if (argv.model) {
+  try {
+    modelService.setGlobalOverride('modelName', argv.model);
+  } catch (err) {
+    console.error(`Model override error: ${err.message}`);
+  }
+}
 
 const operations = [
   {
@@ -32,7 +43,7 @@ const operations = [
 
 
 let userInput;
-const useTranscribe = ['true', '1'].includes(argv.transcribe)
+const useTranscribe = !!argv.transcribe;
 if (useTranscribe) {
   const transcriber = new Transcriber("stopword"); // Replace "stopword" with the word you want to trigger the stop
   userInput = await transcriber.startRecording()
@@ -40,7 +51,7 @@ if (useTranscribe) {
   userInput = await edit();
 }
 
-const useIntent = !!['true', '1'].includes(argv.useIntent.toLowerCase())
+const useIntent = argv.useIntent !== false;
 
 const commandType = useIntent ? 'Tool selection' : 'Direct ChatGPT';
 console.error(`Command: ${commandType}`);

package/scripts/summarize-files/index.js

@@ -1,12 +1,36 @@
 import glob from 'glob';
 import { readFile } from 'fs/promises';
 import SummaryMap from '../../src/chains/summary-map/index.js';
+import modelService from '../../src/services/llm-model/index.js';
+import { Command } from 'commander';
 
-// Define your glob pattern here or pass it as a command line argument
-const globPattern = process.argv[2] || './src/**/*.js';
+const program = new Command();
+program
+  .argument('[globPattern]', 'Glob pattern to summarize', './src/**/*.js')
+  .argument('[targetTokens]', 'Target token count', '4097')
+  .option('-p, --privacy', 'Use privacy model if configured')
+  .option('-m, --model <modelName>', 'Specify model name to use');
 
-// Define your target tokens here or pass it as a command line argument
-const targetTokens = process.argv[3] || 4097;
+program.parse(process.argv);
+
+const options = program.opts();
+const [globPattern, targetTokensInput] = program.args;
+const targetTokens = Number(targetTokensInput);
+
+if (options.privacy) {
+  try {
+    modelService.setGlobalOverride('modelName', 'privacy');
+  } catch (err) {
+    console.error(`Privacy model error: ${err.message}`);
+  }
+}
+if (options.model) {
+  try {
+    modelService.setGlobalOverride('modelName', options.model);
+  } catch (err) {
+    console.error(`Model override error: ${err.message}`);
+  }
+}
 
 // Initialize the SummaryMap with the target tokens
 const map = new SummaryMap({

package/src/chains/README.md

@@ -0,0 +1,30 @@
+# Chains
+
+Chains orchestrate multiple verblets or helper functions to perform more complex tasks. Each subdirectory exposes a specific workflow that can be imported as a single function.
+
+Available chains:
+
+- [anonymize](./anonymize)
+- [bulk-map](./bulk-map)
+- [bulk-reduce](./bulk-reduce)
+- [bulk-filter](./bulk-filter)
+- [bulk-group](./bulk-group)
+- [dismantle](./dismantle)
+- [disambiguate](./disambiguate)
+- [intersections](./intersections)
+- [list](./list)
+- [questions](./questions)
+- [socratic](./socratic)
+- [glossary](./glossary)
+- [scan-js](./scan-js)
+- [sort](./sort)
+- [summary-map](./summary-map)
+- [themes](./themes)
+- [set-interval](./set-interval)
+- [test](./test)
+- [test-advice](./test-advice)
+- [veiled-variants](./veiled-variants)
+- [collect-terms](./collect-terms) - gather complex vocabulary
+
+Chains are free to use any utilities from [`../lib`](../lib/README.md) and often rely on one or more verblets from [`../verblets`](../verblets/README.md).
+

package/src/chains/anonymize/README.md

@@ -0,0 +1,21 @@
+# anonymize
+
+Remove personal style, references, and formatting from text to conceal the original author. The chain runs through your configured LLM models, so it works with fully private or self‑hosted LLMs.
+
+Supported methods: `STRICT`, `BALANCED`, and `LIGHT` to control how aggressively style is removed.
+
+
+```javascript
+import anonymize, { anonymizeMethod } from './index.js';
+
+const message = `As a software lead in Chicago, I've found our new UI framework helps junior devs ramp up fast.`;
+
+const { text } = await anonymize({
+  text: message,
+  method: anonymizeMethod.STRICT,
+});
+
+console.log(text);
+// => "The new UI framework shortens the learning curve for new developers."
+```
+