@far-world-labs/verblets 0.2.0 → 0.3.2

package/scripts/generate-verblet/index.js

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

package/scripts/run.sh

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

package/scripts/runner/index.js

@@ -1,56 +0,0 @@
-
-import chatGPT, {
-  getRedis,
-  list,
-  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', {
-    forceQuery: true,
-    modelOptions: {
-      tools: schemas
-    },
-  });
-
-  const functions = {
-    list: async (listName, options) => {
-      return await list(listName, options);
-    }
-  };
-
-  if (typeof results === 'string') {
-    console.error(results);
-    return
-  }
-  console.error(await functions[results.name](results.arguments.name, results.arguments.options));
-}, { maxRetries: 0 });
-
-await (await getRedis()).disconnect();

package/scripts/simple-editor/README.md

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

package/scripts/simple-editor/index.js

@@ -1,79 +0,0 @@
-import dotenv from 'dotenv/config';
-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 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 = [
-  {
-    name: 'bool',
-    fn: ({ text }) => {
-      return bool(text, { forceQuery: true });
-    }
-  },
-];
-
-
-let userInput;
-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()
-} else {
-  userInput = await edit();
-}
-
-const useIntent = argv.useIntent !== false;
-
-const commandType = useIntent ? 'Tool selection' : 'Direct ChatGPT';
-console.error(`Command: ${commandType}`);
-const userInputDisplay = userInput.trim().split('\n')
-  .map(line => `| ${line}`)
-  .join('\n');
-
-console.error(userInputDisplay);
-
-let result;
-if (!useIntent) {
-  result = await chatGPT(userInput);
-} else {
-  const intentFound = await auto(userInput, { forceQuery: true });
-
-  const op = operations.find(option => {
-    return option.name === intentFound.name;
-  });
-
-  result = await op.fn(...intentFound.functionArgsAsArray);
-}
-
-console.error(result);
-
-await (await getRedis()).disconnect();

package/scripts/summarize-files/index.js

@@ -1,70 +0,0 @@
-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';
-
-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');
-
-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({
-    targetTokens: targetTokens
-});
-
-glob(globPattern, async (err, files) => {
-    if (err) {
-        console.error(err);
-        return;
-    }
-
-    const filePromises = files.map(async (file) => {
-        try {
-            const content = await readFile(file, 'utf8');
-            // Set each file content with its respective filepath as a key
-            map.set(file, {
-                key: file,
-                value: content,
-                weight: 1,
-                type: 'code'
-            });
-        } catch (err) {
-            console.error(`Error reading file ${file}:`, err);
-        }
-    });
-
-    // When all file read operations complete
-    await Promise.all(filePromises);
-    const entries = Array.from(await map.entries());
-
-    // Loop over each key/value and print it to stdout
-    for (const [key, value] of entries) {
-        console.log(`## ${key}\n`);
-        console.log(`\`\`\`js\n${value}\n\`\`\``);
-    }
-});

package/src/chains/README.md

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

@@ -1,21 +0,0 @@
-# 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."
-```
-

package/src/chains/anonymize/index.examples.js

@@ -1,75 +0,0 @@
-import { describe, it } from 'vitest';
-import { expect } from 'chai';
-import { anonymize, anonymizeMethod } from './index.js';
-
-const sampleText = `As a seasoned engineer from Silicon Valley, I've found that React's 
-component lifecycle is like a well-oiled machine - understanding the mounting 
-phase is crucial, especially with those pesky useEffect hooks. Trust me, after 
-10 years of experience, proper cleanup is key to avoiding memory leaks!`;
-
-describe('anonymize examples', () => {
-  it.only('should anonymize text using strict method', { timeout: 60_000 }, async () => {
-    const input = {
-      text: sampleText,
-      method: anonymizeMethod.STRICT,
-    };
-
-    const result = await anonymize(input);
-
-    expect(result).to.have.property('text');
-    expect(result).to.have.property('stages');
-    expect(result.stages).to.have.property('distinctiveContentRemoved');
-    expect(result.stages).to.have.property('structureNormalized');
-    expect(result.stages).to.have.property('patternsSuppressed');
-
-    // Verify anonymization removed personal markers
-    expect(result.text).to.not.include('Silicon Valley');
-    expect(result.text).to.not.include('10 years of experience');
-    expect(result.text).to.not.include('Trust me');
-
-    // Verify metaphors and idioms are removed
-    expect(result.text).to.not.include('well-oiled machine');
-    expect(result.text).to.not.include('pesky');
-
-    // Verify the text has been transformed
-    expect(result.text).to.not.equal(sampleText);
-    expect(result.text.length).to.be.lessThan(sampleText.length);
-  });
-
-  it('should preserve more content with balanced method', { timeout: 60_000 }, async () => {
-    const input = {
-      text: sampleText,
-      method: anonymizeMethod.BALANCED,
-    };
-
-    const result = await anonymize(input);
-
-    // Verify some personal markers are still removed
-    expect(result.text).to.not.include('Silicon Valley');
-    expect(result.text).to.not.include('Trust me');
-
-    // But technical content is more preserved
-    expect(result.text.length).to.be.greaterThan(
-      (await anonymize({ text: sampleText, method: anonymizeMethod.STRICT })).text.length
-    );
-  });
-
-  it('should minimally transform text with light method', { timeout: 60_000 }, async () => {
-    const input = {
-      text: sampleText,
-      method: anonymizeMethod.LIGHT,
-    };
-
-    const result = await anonymize(input);
-
-    // Verify minimal transformation
-    expect(result.text.length).to.be.greaterThan(
-      (await anonymize({ text: sampleText, method: anonymizeMethod.BALANCED })).text.length
-    );
-
-    // Only the most obvious personal markers should be removed
-    expect(result.text).to.not.include('Trust me');
-
-    expect(result.text).to.not.include("I've found");
-  });
-});

package/src/chains/anonymize/index.js

@@ -1,121 +0,0 @@
-import { run } from '../../lib/chatgpt/index.js';
-
-export const anonymizeMethod = {
-  STRICT: 'strict',
-  BALANCED: 'balanced',
-  LIGHT: 'light',
-};
-
-const METHODS = Object.values(anonymizeMethod);
-
-const validateInput = (input) => {
-  if (!input || typeof input !== 'object') {
-    throw new Error('Input must be an object');
-  }
-
-  const { text, method, context } = input;
-
-  if (!text || typeof text !== 'string') {
-    throw new Error('Input must include a text string');
-  }
-
-  if (!method || !METHODS.includes(method)) {
-    throw new Error(`Method must be one of: ${METHODS.join(', ')}`);
-  }
-
-  if (context !== undefined && typeof context !== 'string') {
-    throw new Error('Context must be a string if provided');
-  }
-
-  return { text, method, context };
-};
-
-const stage1Prompt = (text, context) => `
-Remove Distinctive Content and Markers
- - Identify and replace every distinctive or uncommon word, phrase, or sentence structure with the most widely used, nondescript alternative.
- - Remove all idioms, metaphors, analogies, cultural references, personal perspectives, and subjective tones.
- - Eliminate any explicit or implicit references to the author's identity, background, education, expertise, region, or intent.
-
-${context ? `Context: ${context}\n` : ''}
-Text to process:
-${text}
-
-Return ONLY the processed text, with no explanations or additional content.`;
-
-const stage2Prompt = (text, context) => `
-Normalize Structure, Formatting, and Tone
- - Restructure sentences and paragraphs to strictly follow standard, average patterns in length, order, and construction. Avoid any distinctive rhythm, complexity, or flow.
- - Uniformly normalize punctuation, formatting, and paragraphing; avoid any variation or emphasis that could signal style.
- - Strip out all emotional, evaluative, or expressive language, enforcing a neutral, impersonal, and objective tone.
-
- ${context ? `Context: ${context}\n` : ''}
- Text to process:
-${text}
-
-Return ONLY the normalized text, with no explanations or additional content.`;
-
-const stage3Prompt = (text, context) => `
-Stage 3: Suppress Latent Stylistic Patterns
- - Review for and suppress any recurring linguistic patterns, syntactic habits, or structural quirks—even if they appear common.
- - For all possible ways to phrase content, always select the plainest, most generic, and least distinctive form.
- - Ensure the final text reads as if generated by an automated system, with no evidence of personality, emotion, region, or any unique authorial traits.
-
- ${context ? `Context: ${context}\n` : ''}
-Text to process:
-${text}
-
-Return ONLY the final anonymized text, with no explanations or additional content.`;
-
-const anonymize = async (input, config = {}) => {
-  const { text, method, context } = validateInput(input);
-  const { llm, ...options } = config;
-
-  // Stage 1: Remove distinctive content
-  const stage1Result = await run(stage1Prompt(text, method, context), {
-    modelOptions: { modelName: 'privacy', ...llm },
-    ...options,
-  });
-
-  if (method === anonymizeMethod.LIGHT) {
-    return {
-      text: stage1Result,
-      stages: {
-        distinctiveContentRemoved: stage1Result,
-      },
-    };
-  }
-
-  // Stage 2: Normalize structure and tone
-  const stage2Result = await run(stage2Prompt(stage1Result, method), {
-    modelOptions: { modelName: 'privacy', ...llm },
-    ...options,
-  });
-
-  if (method === anonymizeMethod.BALANCED) {
-    return {
-      text: stage2Result,
-      stages: {
-        distinctiveContentRemoved: stage1Result,
-        structureNormalized: stage2Result,
-      },
-    };
-  }
-
-  // Stage 3: Suppress stylistic patterns
-  const stage3Result = await run(stage3Prompt(stage2Result, method), {
-    modelOptions: { modelName: 'privacy', ...llm },
-    ...options,
-  });
-
-  return {
-    text: stage3Result,
-    stages: {
-      distinctiveContentRemoved: stage1Result,
-      structureNormalized: stage2Result,
-      patternsSuppressed: stage3Result,
-    },
-  };
-};
-
-export { anonymize };
-export default anonymize;

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

@@ -1,78 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { anonymize, anonymizeMethod } from './index.js';
-
-vi.mock('./index.js', () => {
-  return {
-    anonymize: vi.fn(async (input) => {
-      if (!input || typeof input.text !== 'string' || !input.text.trim()) {
-        throw new Error('Text is required');
-      }
-      if (!input.method) {
-        throw new Error('Method is required');
-      }
-      if (!['STRICT', 'BALANCED', 'LIGHT'].includes(input.method)) {
-        throw new Error('Invalid method');
-      }
-      return {
-        text: 'anonymized',
-        stages: {
-          distinctiveContentRemoved: true,
-          structureNormalized: true,
-          patternsSuppressed: true,
-        },
-      };
-    }),
-    anonymizeMethod: { STRICT: 'STRICT', BALANCED: 'BALANCED', LIGHT: 'LIGHT' },
-  };
-});
-
-describe('anonymize', () => {
-  it('should return an object with text and stages properties', async () => {
-    const input = {
-      text: 'Test input',
-      method: anonymizeMethod.LIGHT,
-    };
-
-    const result = await anonymize(input);
-
-    expect(result).to.have.property('text');
-    expect(result).to.have.property('stages');
-    expect(result.stages).to.have.property('distinctiveContentRemoved');
-    expect(result.stages).to.have.property('structureNormalized');
-    expect(result.stages).to.have.property('patternsSuppressed');
-  });
-
-  it('should throw an error if method is not provided', async () => {
-    const input = {
-      text: 'Test input',
-    };
-
-    await expect(anonymize(input)).rejects.toThrow('Method is required');
-  });
-
-  it('should throw an error if method is invalid', async () => {
-    const input = {
-      text: 'Test input',
-      method: 'INVALID',
-    };
-
-    await expect(anonymize(input)).rejects.toThrow('Invalid method');
-  });
-
-  it('should throw an error if text is not provided', async () => {
-    const input = {
-      method: anonymizeMethod.LIGHT,
-    };
-
-    await expect(anonymize(input)).rejects.toThrow('Text is required');
-  });
-
-  it('should throw an error if text is empty', async () => {
-    const input = {
-      text: '',
-      method: anonymizeMethod.LIGHT,
-    };
-
-    await expect(anonymize(input)).rejects.toThrow('Text is required');
-  });
-});