@far-world-labs/verblets 0.1.1 → 0.1.3

package/src/chains/summary-map/index.js

@@ -1,15 +1,10 @@
-/* eslint-disable no-await-in-loop */
-
 import chatGPT from '../../lib/chatgpt/index.js';
 import pave from '../../lib/pave/index.js';
 import shortenText from '../../lib/shorten-text/index.js';
-import {
-  summarize as basicSummarize,
-  tokenBudget,
-} from '../../prompts/index.js';
+import { summarize as basicSummarize, tokenBudget } from '../../prompts/index.js';
 import modelService from '../../services/llm-model/index.js';
 
-const summarize = ({ budget, type, value, fixes = [] }) => {
+const summarize = ({ budget, type, value, fixes = [], modelOptions, privacy }) => {
   if (budget) {
     fixes.push(tokenBudget(budget));
   }
@@ -22,9 +17,19 @@ const summarize = ({ budget, type, value, fixes = [] }) => {
     fixes.push('Remove the function header if it exists.');
   }
 
+  if (privacy?.whitelist) {
+    fixes.push(`Only share information matching: ${privacy.whitelist}.`);
+  }
+
+  if (privacy?.blacklist) {
+    fixes.push(`Do not share information matching: ${privacy.blacklist}.`);
+  }
+
   const fixesAsBullets = fixes.map((fix) => ` - ${fix}`);
 
-  return chatGPT(basicSummarize(value, `${fixesAsBullets.join('\n')}`));
+  return chatGPT(basicSummarize(value, `${fixesAsBullets.join('\n')}`), {
+    modelOptions,
+  });
 };
 
 /**
@@ -34,7 +39,8 @@ const summarize = ({ budget, type, value, fixes = [] }) => {
 export default class SummaryMap extends Map {
   constructor({
     maxTokensPerValue,
-    model = modelService.getBestAvailableModel(),
+    model = modelService.getBestPublicModel(),
+    modelOptions = { modelName: model.name },
     promptText,
     targetTokens,
     // used with promptText, when targetTokens isn't supplied
@@ -45,6 +51,7 @@ export default class SummaryMap extends Map {
     this.data = new Map();
     this.isCacheValid = false;
     this.maxTokensPerValue = maxTokensPerValue ?? model.maxTokens;
+    this.modelOptions = { modelName: model.name, ...modelOptions };
 
     if (targetTokens) {
       this.targetTokens = targetTokens;
@@ -52,13 +59,9 @@ export default class SummaryMap extends Map {
       this.promptTokens = model.toTokens(promptText).length;
       const maxModelTokens = model.maxTokens;
       const remainingTokens = maxModelTokens - this.promptTokens;
-      this.targetTokens = Math.floor(
-        remainingTokens - remainingTokens * targetTokensTotalRatio
-      );
+      this.targetTokens = Math.floor(remainingTokens - remainingTokens * targetTokensTotalRatio);
     } else {
-      throw new Error(
-        'Either "promptText" and "model" or "targetTokens" must be provided.'
-      );
+      throw new Error('Either "promptText" and "model" or "targetTokens" must be provided.');
     }
   }
 
@@ -68,16 +71,12 @@ export default class SummaryMap extends Map {
       .reduce((sum, valueObject) => {
         return sum + (valueObject.weight ?? 1) * valueObject.value.length;
       }, 0);
-    const sortedEntries = [...this.data.entries()].sort(
-      (a, b) => a[1].weight - b[1].weight
-    );
+    const sortedEntries = [...this.data.entries()].sort((a, b) => a[1].weight - b[1].weight);
 
     const budgets = [];
     for (const [entryKey, valueObject] of sortedEntries) {
       const sizeWeight = valueObject.value.length * (valueObject.weight ?? 1);
-      const budget = Math.floor(
-        (sizeWeight / totalSizeWeight) * this.targetTokens
-      );
+      const budget = Math.floor((sizeWeight / totalSizeWeight) * this.targetTokens);
 
       if (valueObject.weight) {
         budgets.push({ key: entryKey, budget });
@@ -95,16 +94,38 @@ export default class SummaryMap extends Map {
     for (const { key, budget } of budgets) {
       const valueObject = this.data.get(key);
 
+      const entryModelOptions = {
+        ...this.modelOptions,
+        ...valueObject.modelOptions,
+      };
+
+      if (valueObject.privacy?.whitelist || valueObject.privacy?.blacklist) {
+        entryModelOptions.modelName = 'privacy';
+      }
+
       const value = shortenText(valueObject.value, {
         targetTokenCount: this.maxTokensPerValue,
+        model: modelService.getModel(entryModelOptions.modelName),
       });
 
       // omit weight to skip summarization
       let summarizedValue = value;
       if (budget) {
+        const summarizeModelOptions = {
+          ...this.modelOptions,
+          ...valueObject.modelOptions,
+        };
+
+        if (valueObject.privacy?.whitelist || valueObject.privacy?.blacklist) {
+          summarizeModelOptions.modelName = 'privacy';
+        }
+
+        // eslint-disable-next-line no-await-in-loop
         summarizedValue = await summarize({
           budget,
           fixes: valueObject.fixes,
+          modelOptions: summarizeModelOptions,
+          privacy: valueObject.privacy,
           type: valueObject.type,
           value,
         });
@@ -189,10 +210,7 @@ export default class SummaryMap extends Map {
   }
 
   pavedSummaryResultStale() {
-    return Array.from(this.entriesStale()).reduce(
-      (acc, [k, v]) => pave(acc, k, v),
-      {}
-    );
+    return Array.from(this.entriesStale()).reduce((acc, [k, v]) => pave(acc, k, v), {});
   }
 
   pavedSummaryResult() {

package/src/chains/summary-map/index.spec.js

@@ -1,7 +1,51 @@
 import { describe, expect, it, vi } from 'vitest';
-
-import SummaryMap from './index.js';
 import pave from '../../lib/pave/index.js';
+import SummaryMap from './index.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+
+vi.mock('../../services/llm-model/index.js', () => ({
+  default: {
+    negotiateModel: vi.fn().mockReturnValue('fastGood'),
+    getBestPublicModel: vi.fn().mockReturnValue({
+      name: 'fastGood',
+      tokenizer: (text) => text.split(' '),
+      maxContextWindow: 128000,
+      maxOutputTokens: 16384,
+      toTokens(text) {
+        return this.tokenizer(text);
+      },
+      budgetTokens(text, { completionMax = Infinity } = {}) {
+        const prompt = this.toTokens(text).length;
+        const total = this.maxContextWindow;
+        const completion = Math.min(Math.min(total - prompt, this.maxOutputTokens), completionMax);
+        return {
+          completion,
+          prompt,
+          total,
+        };
+      },
+    }),
+    getModel: vi.fn().mockReturnValue({
+      name: 'fastGood',
+      tokenizer: (text) => text.split(' '),
+      maxContextWindow: 128000,
+      maxOutputTokens: 16384,
+      toTokens(text) {
+        return this.tokenizer(text);
+      },
+      budgetTokens(text, { completionMax = Infinity } = {}) {
+        const prompt = this.toTokens(text).length;
+        const total = this.maxContextWindow;
+        const completion = Math.min(Math.min(total - prompt, this.maxOutputTokens), completionMax);
+        return {
+          completion,
+          prompt,
+          total,
+        };
+      },
+    }),
+  },
+}));
 
 vi.mock('../../lib/chatgpt/index.js', () => ({
   default: vi.fn().mockImplementation((text) => {
@@ -15,7 +59,8 @@ vi.mock('../../lib/chatgpt/index.js', () => ({
   }),
 }));
 
-const legalText = `Pursuant to the adjudication of a force majeure clause within the context of contractual`;
+const legalText =
+  'Pursuant to the adjudication of a force majeure clause within the context of contractual';
 
 const codeText = `import numpy as np
 
@@ -37,13 +82,36 @@ const examples = [
       { key: 'example.code', resultLength: 25, budget: [20, 40] },
     ],
   },
+  {
+    name: 'Model options and privacy',
+    inputs: {
+      targetTokens: 50,
+      modelOptions: { modelName: 'fastGood' },
+      keys: [
+        {
+          key: 'example.text',
+          value: legalText,
+          weight: 1,
+          type: 'text',
+          privacy: { blacklist: 'names' },
+        },
+        { key: 'example.code', value: codeText, weight: 0.5, type: 'code' },
+      ],
+    },
+    wants: [
+      { key: 'example.text', resultLength: 50 },
+      { key: 'example.code', resultLength: 25 },
+    ],
+  },
 ];
 
 describe('Summary map', () => {
   examples.forEach((example) => {
     it(example.name, async () => {
+      vi.clearAllMocks();
       const map = new SummaryMap({
         targetTokens: example.inputs.targetTokens,
+        ...(example.inputs.modelOptions && { modelOptions: example.inputs.modelOptions }),
       });
 
       for (const input of example.inputs.keys) {
@@ -73,6 +141,13 @@ describe('Summary map', () => {
           expect(found.budget).lt(want.budget[1]);
         }
       }
+
+      if (example.name === 'Model options and privacy') {
+        const callWithPrivacy = chatGPT.mock.calls.find(
+          (c) => c[1]?.modelOptions?.modelName === 'privacy'
+        );
+        expect(callWithPrivacy).toBeTruthy();
+      }
     });
   });
 });

package/src/chains/test/index.js

@@ -3,10 +3,7 @@ import path from 'node:path';
 
 import { errorRunningTests } from '../../constants/messages.js';
 import chatGPT from '../../lib/chatgpt/index.js';
-import {
-  constants as promptConstants,
-  wrapVariable,
-} from '../../prompts/index.js';
+import { constants as promptConstants, wrapVariable } from '../../prompts/index.js';
 import modelService from '../../services/llm-model/index.js';
 import toObject from '../../verblets/to-object/index.js';
 
@@ -19,11 +16,9 @@ const {
   useLineNumber,
 } = promptConstants;
 
-const contentIsChecksExamined =
-  'These items were checked in an examination of the text:';
+const contentIsChecksExamined = 'These items were checked in an examination of the text:';
 const contentIsExamined = 'The text examined:';
-const findCodeImprovements =
-  'Find specific improvements in the following code, not nitpicks.';
+const findCodeImprovements = 'Find specific improvements in the following code, not nitpicks.';
 const gatherAsTestJSON =
   'Gather these discovered issues into a JSON format my tests module can consume.';
 
@@ -67,11 +62,8 @@ ${contentIsExample} ${wrapVariable(testExamplesJSON, { tag: 'example' })}
 ${onlyJSONArray}
 `;
 
-export default async (
-  filePath,
-  instructions = findCodeImprovements,
-  model = modelService.getBestAvailableModel()
-) => {
+export default async (filePath, instructions = findCodeImprovements, config = {}) => {
+  const { model = modelService.getBestPublicModel(), llm, ...options } = config;
   const enableRegex = new RegExp(process.env.ENABLE_AI_TESTS ?? '^$');
   if (!enableRegex.test(filePath)) {
     return [];
@@ -87,7 +79,9 @@ export default async (
     const checksResult = await chatGPT(checksPromptCreated, {
       modelOptions: {
         maxTokens: checksBudget.completion,
+        ...llm,
       },
+      ...options,
     });
 
     const testsPromptCreated = testsPrompt(text, instructions, checksResult);
@@ -97,7 +91,9 @@ export default async (
       await chatGPT(testsPromptCreated, {
         modelOptions: {
           maxTokens: testsBudget.completion,
+          ...llm,
         },
+        ...options,
       })
     );
 

package/src/chains/test-advice/index.js

@@ -1,18 +1,17 @@
 import test from '../test/index.js';
 
-const boundaryIssues =
-  'Run the code with 5 boundary value test cases and report any that fail';
+const boundaryIssues = 'Run the code with 5 boundary value test cases and report any that fail';
 
 const successIssues =
   'Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.';
 
-const failureIssues = `Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.`;
+const failureIssues =
+  "Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.";
 
 const defectIssues =
   'Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.';
 
-const bestPracticesIssues =
-  'Suggest 5 best practices improvements for this code.';
+const bestPracticesIssues = 'Suggest 5 best practices improvements for this code.';
 
 const cleanCodeIssues = 'Suggest 5 "clean code" improvements for this code.';
 

package/src/chains/themes/README.md

@@ -0,0 +1,20 @@
+# themes
+
+Reveal a text's key themes and map them back to the sentences where they appear. The chain first scans fragments in batches to collect possible themes, then runs a consolidation step to normalize and deduplicate them. Optionally it returns a per-sentence map showing which themes surface in each line.
+
+```javascript
+import themes from './index.js';
+
+const news = `The storm toppled trees and damaged homes. Volunteers quickly arrived with food and tools. Their kindness inspired hope throughout the town.`;
+
+const result = await themes(news, { sentenceMap: true });
+/* {
+ * themes: ['disaster recovery', 'community', 'hope'],
+ * sentenceThemes: [
+ *   [0, ['disaster recovery']],
+ *   [44, ['community']],
+ *   [114, ['hope']]
+ * ]
+ */
+```
+

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

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import themes from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+describe('themes chain', () => {
+  it(
+    'extracts key themes',
+    async () => {
+      const text = `Coffee shops are opening all over town. People love the
+new flavors but complain about long lines. Local farmers provide beans while
+young entrepreneurs drive innovation.`;
+      const result = await themes(text, { topN: 2 });
+      expect(Array.isArray(result)).toBe(true);
+    },
+    longTestTimeout
+  );
+});

package/src/chains/themes/index.js

@@ -0,0 +1,28 @@
+import bulkReduce from '../bulk-reduce/index.js';
+import shuffle from 'lodash/shuffle.js';
+
+const splitText = (text) =>
+  text
+    .split(/\n{2,}/)
+    .map((p) => p.trim())
+    .filter(Boolean);
+
+export default async function themes(text, config = {}) {
+  const { chunkSize = 5, topN, llm, ...options } = config;
+  const pieces = splitText(text);
+  const reducePrompt =
+    'Update the accumulator with short themes from this text. Avoid duplicates. Return a comma-separated list of themes.';
+  const firstPass = await bulkReduce(shuffle(pieces), reducePrompt, { chunkSize, llm, ...options });
+  const rawThemes = firstPass
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+
+  const limitText = topN ? `Limit to the top ${topN} themes.` : 'Return all meaningful themes.';
+  const refinePrompt = `Refine the accumulator by merging similar themes. ${limitText} Return a comma-separated list.`;
+  const final = await bulkReduce(rawThemes, refinePrompt, { chunkSize, llm, ...options });
+  return final
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+}

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

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import themes from './index.js';
+import bulkReduce from '../bulk-reduce/index.js';
+
+vi.mock('../bulk-reduce/index.js');
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('themes chain', () => {
+  it('reduces in two passes', async () => {
+    bulkReduce.mockResolvedValueOnce('a, b, c').mockResolvedValueOnce('a, c');
+    const text = 'x\n\ny';
+    const result = await themes(text, { chunkSize: 1, topN: 2 });
+    expect(result).toStrictEqual(['a', 'c']);
+    expect(bulkReduce).toHaveBeenCalledTimes(2);
+  });
+});

package/src/chains/veiled-variants/index.examples.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import veiledVariants from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+describe('veiledVariants example', () => {
+  it(
+    'obscures a sensitive query',
+    async () => {
+      const result = await veiledVariants({
+        prompt:
+          'If pigeons are government spies, how do I ask for counter-surveillance tips without sounding paranoid?',
+      });
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length, `Saw: "${result.join('", "')}"`).toBe(15);
+    },
+    longTestTimeout
+  );
+});

package/src/chains/veiled-variants/index.js

@@ -0,0 +1,107 @@
+import { run } from '../../lib/chatgpt/index.js';
+import { constants as promptConstants, wrapVariable } from '../../prompts/index.js';
+
+const { onlyJSONStringArray } = promptConstants;
+
+export const scientificFramingPrompt = (prompt) => `${onlyJSONStringArray}
+
+Recast the intent as if asked by a scientific researcher. Generate exactly 5 masked alternatives.
+
+Apply these requirements:
+ - Replace casual terms with academic phrasing
+ - Invoke terminology from biology, epidemiology, diagnostics, or public health
+ - Never use slang, simplifications, or direct synonyms of the original prompt
+ - Frame each as a legitimate research query
+ - You MUST generate exactly 5 alternatives. No more, no less.
+ - Output must be a JSON array of exactly 5 strings
+
+${wrapVariable(prompt, { tag: 'intent' })}
+
+${onlyJSONStringArray}`;
+
+export const causalFramePrompt = (prompt) => `${onlyJSONStringArray}
+
+Generate queries that explore causes, co-conditions, or plausible consequences of the prompt topic. Generate exactly 5 masked alternatives.
+
+Apply these requirements:
+ - Focus on surrounding or adjacent issues rather than the central sensitive term
+ - Frame each as a legitimate research query
+ - Explore what leads to, accompanies, or results from the topic
+ - You MUST generate exactly 5 alternatives. No more, no less.
+ - Output must be a JSON array of exactly 5 strings
+
+${wrapVariable(prompt, { tag: 'intent' })}
+
+${onlyJSONStringArray}`;
+
+export const softCoverPrompt = (prompt) => `${onlyJSONStringArray}
+
+Reframe the prompt as general wellness or diagnostic concerns. Generate exactly 5 masked alternatives.
+
+Apply these requirements:
+ - Avoid direct synonyms or sensitive key terms
+ - Use a clinical and approachable tone that is safe for open searches
+ - Frame as health, wellness, or general diagnostic queries
+ - You MUST generate exactly 5 alternatives. No more, no less.
+ - Output must be a JSON array of exactly 5 strings
+
+${wrapVariable(prompt, { tag: 'intent' })}
+
+${onlyJSONStringArray}`;
+
+const veiledVariants = async ({ prompt, modelName = 'privacy' }) => {
+  const prompts = [
+    scientificFramingPrompt(prompt),
+    causalFramePrompt(prompt),
+    softCoverPrompt(prompt),
+  ];
+  const options = { modelOptions: { modelName } };
+  const results = await Promise.all(prompts.map((p) => run(p, options)));
+  return results
+    .map((r) => {
+      try {
+        // First try to extract JSON array from response
+        const jsonMatch = r.match(/\[[\s\S]*?\]/);
+        if (jsonMatch) {
+          const parsed = JSON.parse(jsonMatch[0]);
+          if (Array.isArray(parsed) && parsed.length > 0) {
+            return parsed;
+          }
+        }
+
+        // If no valid JSON array found, try to parse the entire response
+        const parsed = JSON.parse(r);
+        if (Array.isArray(parsed)) {
+          return parsed;
+        }
+
+        // If response is not an array, wrap it in an array
+        return [parsed];
+      } catch (error) {
+        // If JSON parsing fails completely, try to extract meaningful content
+        const trimmed = r.trim();
+
+        // If it's a long prose response, try to extract sentences or phrases
+        if (trimmed.length > 200) {
+          // Split by sentences and take meaningful ones
+          const sentences = trimmed.split(/[.!?]+/).filter((s) => s.trim().length > 20);
+          if (sentences.length >= 3) {
+            return sentences.slice(0, 5).map((s) => s.trim());
+          }
+        }
+
+        // If it contains quoted strings, extract them
+        const quotes = trimmed.match(/"([^"]+)"/g);
+        if (quotes && quotes.length > 0) {
+          return quotes.map((q) => q.replace(/"/g, ''));
+        }
+
+        // Fallback: return the raw response as a single item
+        console.warn('Failed to parse JSON response, using raw text:', error.message);
+        return [trimmed];
+      }
+    })
+    .flat();
+};
+
+export default veiledVariants;

package/src/chains/veiled-variants/index.spec.js

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+import veiledVariants from './index.js';
+
+let call = 0;
+
+const runMock = vi.fn().mockImplementation(() => {
+  call += 1;
+  if (call === 1) {
+    return '["s1","s2","s3","s4","s5"]';
+  }
+  if (call === 2) {
+    return '["c1","c2","c3","c4","c5"]';
+  }
+  return '["w1","w2","w3","w4","w5"]';
+});
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  run: (...args) => runMock(...args),
+}));
+
+describe('veiledVariants', () => {
+  it('returns 15 masked queries', async () => {
+    const result = await veiledVariants({ prompt: 'secret' });
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBe(15);
+    expect(runMock).toHaveBeenCalledTimes(3);
+    runMock.mock.calls.forEach((callArgs) => {
+      expect(callArgs[1]).toStrictEqual({ modelOptions: { modelName: 'privacy' } });
+    });
+  });
+
+  it('allows overriding model name', async () => {
+    runMock.mockClear();
+    call = 0;
+    await veiledVariants({ prompt: 'secret', modelName: 'fastGood' });
+    runMock.mock.calls.forEach((callArgs) => {
+      expect(callArgs[1]).toStrictEqual({ modelOptions: { modelName: 'fastGood' } });
+    });
+  });
+});

package/src/constants/common.js

@@ -1,5 +1,3 @@
-/* eslint-disable import/prefer-default-export */
-
 export const longTestTimeout = 120000;
 
 export const maxRetries = 3;