@far-world-labs/verblets 0.2.0 → 0.3.2

package/src/verblets/intersection/index.spec.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import intersection from './index.js';
-
-vi.mock('../../lib/chatgpt/index.js', () => ({
-  default: vi.fn(async (prompt) => {
-    console.log('Mock received prompt:', prompt);
-    // Look for quoted items in the prompt
-    const match = prompt.match(/"([^"]+)"/);
-    if (match) {
-      const itemsLine = match[1];
-      const items = itemsLine.split(' | ');
-      const commonalities = items.map((item) => `common: ${item}`);
-      // Add combinations
-      for (let i = 0; i < items.length; i++) {
-        for (let j = i + 1; j < items.length; j++) {
-          commonalities.push(`common: ${items[i]} | ${items[j]}`);
-        }
-      }
-      // Add all items combination
-      if (items.length > 2) {
-        commonalities.push(`common: ${items.join(' | ')}`);
-      }
-      console.log('Mock returning:', JSON.stringify(commonalities));
-      return JSON.stringify(commonalities);
-    }
-    console.log('Mock: no match found, returning empty array');
-    return JSON.stringify([]);
-  }),
-}));
-
-describe('intersection verblet', () => {
-  it('describes commonalities between sets', async () => {
-    const result = await intersection(['a', 'b', 'c']);
-    expect(result).toStrictEqual([
-      'common: a',
-      'common: b',
-      'common: c',
-      'common: a | b',
-      'common: a | c',
-      'common: b | c',
-      'common: a | b | c',
-    ]);
-  });
-
-  it('includes custom instructions in the prompt', async () => {
-    const chatGPT = (await import('../../lib/chatgpt/index.js')).default;
-    await intersection(['x', 'y', 'z'], { instructions: 'focus on features' });
-    expect(chatGPT).toHaveBeenCalledWith(
-      expect.stringContaining('focus on features'),
-      expect.any(Object)
-    );
-  });
-
-  it('returns empty array when model returns empty response', async () => {
-    const chatGPT = (await import('../../lib/chatgpt/index.js')).default;
-    chatGPT.mockResolvedValueOnce('[]');
-    const result = await intersection(['x', 'y']);
-    expect(result).toStrictEqual([]);
-  });
-});

package/src/verblets/intersection/intersection-result.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "items": {
-      "type": "array",
-      "description": "Array of common features, instances, or relational links shared by all items",
-      "items": {
-        "type": "string",
-        "description": "A common feature, instance, or relational link"
-      }
-    }
-  },
-  "required": ["items"],
-  "additionalProperties": false
-} 

package/src/verblets/list-expand/README.md

@@ -1,10 +0,0 @@
-# list-expand
-
-Generate additional items that fit naturally with the given list. The function sends the provided items to ChatGPT and requests more entries of the same kind, returning the expanded list.
-
-```javascript
-import listExpand from './index.js';
-
-await listExpand(['red', 'green'], 5);
-// => ['red', 'green', 'blue', 'yellow', 'purple']
-```

package/src/verblets/list-expand/index.examples.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import listExpand from './index.js';
-import { longTestTimeout } from '../../constants/common.js';
-
-describe('list-expand examples', () => {
-  it(
-    'expands a short list of fruits',
-    async () => {
-      const result = await listExpand(['apple', 'banana'], 5);
-      expect(result.length).toBeGreaterThanOrEqual(5);
-    },
-    longTestTimeout
-  );
-});

package/src/verblets/list-expand/index.js

@@ -1,104 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import chatGPT from '../../lib/chatgpt/index.js';
-import wrapVariable from '../../prompts/wrap-variable.js';
-
-// Get the directory of this module
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Load the JSON schema for list expand results
- * @returns {Promise<Object>} JSON schema for validation
- */
-async function getListExpandSchema() {
-  const schemaPath = path.join(__dirname, 'list-expand-result.json');
-  return JSON.parse(await fs.readFile(schemaPath, 'utf8'));
-}
-
-/**
- * Create model options for structured outputs
- * @param {string|Object} llm - LLM model name or configuration object
- * @returns {Promise<Object>} Model options for chatGPT
- */
-async function createModelOptions(llm = 'fastGoodCheap') {
-  const schema = await getListExpandSchema();
-
-  const responseFormat = {
-    type: 'json_schema',
-    json_schema: {
-      name: 'list_expand_result',
-      schema,
-    },
-  };
-
-  if (typeof llm === 'string') {
-    return {
-      modelName: llm,
-      response_format: responseFormat,
-    };
-  } else {
-    return {
-      ...llm,
-      response_format: responseFormat,
-    };
-  }
-}
-
-// TODO: This could potentially be refactored to use the list chain (../../chains/list/index.js)
-// for better consistency, but would require adapting the list chain to support this simpler
-// expansion use case without changing the current behavior and test expectations.
-
-const buildPrompt = function (list, count) {
-  const listBlock = wrapVariable(list.join('\n'), { tag: 'list' });
-  return (
-    `Expand <list> with new items that belong to the same category and ` +
-    `match the style of the existing entries. Avoid duplicates or extraneous ` +
-    `text. Continue adding entries until there are at least ${count} in total. ` +
-    `Return a JSON object with an "items" array containing all the expanded items.\n\n${listBlock}`
-  );
-};
-
-/**
- * Expand a list with new items that belong to the same category and match the style.
- * This is a simplified interface to the list chain for expansion use cases.
- *
- * @param {string[]} existingList - The list to expand
- * @param {number} targetCount - Target total count (default: double the input)
- * @param {Object} config - Configuration options including llm settings
- * @returns {Promise<string[]>} Expanded list
- */
-export default async function listExpand(list, count = list.length * 2, config = {}) {
-  const { llm, ...options } = config;
-  const modelOptions = await createModelOptions(llm);
-  const output = await chatGPT(buildPrompt(list, count), { modelOptions, ...options });
-
-  // With structured outputs, response should already be parsed and validated
-  let parsed;
-  if (typeof output === 'string') {
-    try {
-      parsed = JSON.parse(output);
-    } catch {
-      // Handle non-JSON responses (e.g., from mocks or fallback cases)
-      // Split by newlines and filter out empty lines
-      const lines = output
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-      parsed = { items: lines };
-    }
-  } else {
-    parsed = output;
-  }
-
-  // Extract items from the object structure
-  const items = parsed?.items || parsed;
-
-  if (!Array.isArray(items)) {
-    console.warn('Expected items array, got:', typeof items);
-    return [];
-  }
-
-  return items;
-}

package/src/verblets/list-expand/index.spec.js

@@ -1,18 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import listExpand from './index.js';
-
-vi.mock('../../lib/chatgpt/index.js', () => ({
-  default: vi.fn(async (prompt) => {
-    const match = prompt.match(/<list>\n([\s\S]*?)\n<\/list>/);
-    const lines = match ? match[1].split('\n') : [];
-    const extras = lines.map((l) => `${l}-extra`);
-    return [...lines, ...extras].join('\n');
-  }),
-}));
-
-describe('list-expand verblet', () => {
-  it('expands items to at least the requested count', async () => {
-    const result = await listExpand(['alpha', 'beta'], 4);
-    expect(result).toStrictEqual(['alpha', 'beta', 'alpha-extra', 'beta-extra']);
-  });
-});

package/src/verblets/list-expand/list-expand-result.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "items": {
-      "type": "array",
-      "description": "Array of expanded list items",
-      "items": {
-        "type": "string",
-        "description": "A list item that belongs to the same category and matches the style"
-      }
-    }
-  },
-  "required": ["items"],
-  "additionalProperties": false
-} 

package/src/verblets/list-filter/README.md

@@ -1,22 +0,0 @@
-# list-filter
-
-Filter a list with a single ChatGPT call using custom instructions.
-
-```javascript
-import listFilter from './index.js';
-
-const reflections = [
-  'Losing that match taught me the value of persistence.',
-  "I hate losing and it proves I'm worthless.",
-  'After failing my exam, I studied harder and passed the retake.',
-  "No matter what I do, I'll never succeed.",
-];
-const growth = await listFilter(
-  reflections,
-  'keep only reflections that show personal growth or learning from mistakes'
-);
-// => [
-//   'Losing that match taught me the value of persistence.',
-//   'After failing my exam, I studied harder and passed the retake.',
-// ]
-```

package/src/verblets/list-filter/index.examples.js

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import listFilter from './index.js';
-import { longTestTimeout } from '../../constants/common.js';
-
-describe('list-filter examples', () => {
-  it(
-    'filters items with custom instructions',
-    async () => {
-      const entries = [
-        'Losing that match taught me the value of persistence.',
-        "I hate losing and it proves I'm worthless.",
-        'After failing my exam, I studied harder and passed the retake.',
-        "No matter what I do, I'll never succeed.",
-      ];
-      const result = await listFilter(
-        entries,
-        'keep only reflections that show personal growth or learning from mistakes'
-      );
-      expect(result).toStrictEqual([
-        'Losing that match taught me the value of persistence.',
-        'After failing my exam, I studied harder and passed the retake.',
-      ]);
-    },
-    longTestTimeout
-  );
-});

package/src/verblets/list-filter/index.js

@@ -1,18 +0,0 @@
-import chatGPT from '../../lib/chatgpt/index.js';
-import wrapVariable from '../../prompts/wrap-variable.js';
-
-function buildPrompt(list, instructions) {
-  const instructionsBlock = wrapVariable(instructions, { tag: 'instructions' });
-  const listBlock = wrapVariable(list.join('\n'), { tag: 'list' });
-  return `From the <list>, select only the items that satisfy the <instructions>. Return one item per line without numbering. If none match, return an empty string.\n\n${instructionsBlock}\n${listBlock}`;
-}
-
-export default async function listFilter(list, instructions, config = {}) {
-  const { llm, ...options } = config;
-  const output = await chatGPT(buildPrompt(list, instructions), {
-    modelOptions: { ...llm },
-    ...options,
-  });
-  const trimmed = output.trim();
-  return trimmed ? trimmed.split('\n') : [];
-}

package/src/verblets/list-filter/index.spec.js

@@ -1,19 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import listFilter from './index.js';
-
-vi.mock('../../lib/chatgpt/index.js', () => ({
-  default: vi.fn(async (prompt) => {
-    const listMatch = prompt.match(/<list>\n([\s\S]*?)\n<\/list>/);
-    const lines = listMatch ? listMatch[1].split('\n') : [];
-    const instMatch = prompt.match(/"([^"]+)"/);
-    const letter = instMatch ? instMatch[1] : '';
-    return lines.filter((l) => l.includes(letter)).join('\n');
-  }),
-}));
-
-describe('list-filter verblet', () => {
-  it('filters items using instructions', async () => {
-    const result = await listFilter(['alpha', 'beta', 'gamma'], 'm');
-    expect(result).toStrictEqual(['gamma']);
-  });
-});

package/src/verblets/list-find/README.md

@@ -1,11 +0,0 @@
-# list-find
-
-Find the single best match in a list using natural language instructions.
-
-```javascript
-import listFind from './index.js';
-
-const snacks = ['apple pie', 'fruit roll-up', 'carrot sticks'];
-await listFind(snacks, 'which snack feels most nostalgic for kids of the 90s?');
-// => 'fruit roll-up'
-```

package/src/verblets/list-find/index.examples.js

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import listFind from './index.js';
-import { longTestTimeout } from '../../constants/common.js';
-
-describe('list-find examples', () => {
-  it(
-    'finds the item that best fits the instructions',
-    async () => {
-      const books = ['space adventure', 'medieval romance', 'futuristic mystery'];
-      const result = await listFind(books, 'which book sounds most futuristic?');
-      expect(result).toBeDefined();
-    },
-    longTestTimeout
-  );
-});

package/src/verblets/list-find/index.js

@@ -1,17 +0,0 @@
-import chatGPT from '../../lib/chatgpt/index.js';
-import wrapVariable from '../../prompts/wrap-variable.js';
-
-const buildPrompt = (list, instructions) => {
-  const instructionsBlock = wrapVariable(instructions, { tag: 'instructions' });
-  const listBlock = wrapVariable(list.join('\n'), { tag: 'list' });
-  return `From the <list>, select the single item that best satisfies the <instructions>. If none apply, return an empty string.\n\n${instructionsBlock}\n${listBlock}`;
-};
-
-export default async function listFind(list, instructions, config = {}) {
-  const { llm, ...options } = config;
-  const output = await chatGPT(buildPrompt(list, instructions), {
-    modelOptions: { ...llm },
-    ...options,
-  });
-  return output.trim();
-}

package/src/verblets/list-find/index.spec.js

@@ -1,19 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import listFind from './index.js';
-
-vi.mock('../../lib/chatgpt/index.js', () => ({
-  default: vi.fn(async (prompt) => {
-    const listMatch = prompt.match(/<list>\n([\s\S]*?)\n<\/list>/);
-    const lines = listMatch ? listMatch[1].split('\n') : [];
-    const parts = prompt.split('"');
-    const letter = [...parts].reverse().find((p) => /^[a-z]+$/i.test(p.trim())) || '';
-    return lines.find((l) => l.includes(letter)) || '';
-  }),
-}));
-
-describe('list-find verblet', () => {
-  it('finds item using instructions', async () => {
-    const result = await listFind(['alpha', 'beta', 'gamma'], 'find "b"');
-    expect(result).toBe('beta');
-  });
-});

package/src/verblets/list-group/README.md

@@ -1,16 +0,0 @@
-# list-group
-
-Group a list into stable groups using custom instructions. Optionally
-provide a list of categories to maintain consistency across runs.
-
-```javascript
-import listGroup from './index.js';
-
-const categories = ['fruit', 'vegetable'];
-await listGroup(
-  ['apple', 'banana', 'carrot'],
-  'Classify each item',
-  categories
-);
-// => { fruit: ['apple', 'banana'], vegetable: ['carrot'] }
-```

package/src/verblets/list-group/index.examples.js

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import listGroup from './index.js';
-import { longTestTimeout } from '../../constants/common.js';
-
-describe('list-group examples', () => {
-  it(
-    'groups a list into categories',
-    async () => {
-      const items = ['apple', 'beer', 'orange', 'wine', 'banana'];
-      const result = await listGroup(items, 'Group as drinks or food', ['drink', 'food']);
-      expect(typeof result).toBe('object');
-      expect(Object.keys(result).length).toBeGreaterThan(0);
-    },
-    longTestTimeout
-  );
-});

package/src/verblets/list-group/index.js

@@ -1,112 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import chatGPT from '../../lib/chatgpt/index.js';
-import wrapVariable from '../../prompts/wrap-variable.js';
-
-// Get the directory of this module
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Load the JSON schema for list group results
- * @returns {Promise<Object>} JSON schema for validation
- */
-async function getListGroupSchema() {
-  const schemaPath = path.join(__dirname, 'list-group-result.json');
-  return JSON.parse(await fs.readFile(schemaPath, 'utf8'));
-}
-
-/**
- * Create model options for structured outputs
- * @param {string|Object} llm - LLM model name or configuration object
- * @returns {Promise<Object>} Model options for chatGPT
- */
-async function createModelOptions(llm = 'fastGoodCheap') {
-  const schema = await getListGroupSchema();
-
-  const responseFormat = {
-    type: 'json_schema',
-    json_schema: {
-      name: 'list_group_result',
-      schema,
-    },
-  };
-
-  if (typeof llm === 'string') {
-    return {
-      modelName: llm,
-      response_format: responseFormat,
-    };
-  } else {
-    return {
-      ...llm,
-      response_format: responseFormat,
-    };
-  }
-}
-
-const buildPrompt = (list, instructions, categories) => {
-  const instructionsBlock = wrapVariable(instructions, { tag: 'instructions' });
-  const listBlock = wrapVariable(list.join('\n'), { tag: 'list' });
-  const categoryBlock =
-    categories && categories.length
-      ? `${wrapVariable(categories.join('\n'), { tag: 'categories' })}\n`
-      : '';
-  const categoryText = categories && categories.length ? 'one of the <categories>' : 'a group';
-
-  return `Assign each line in <list> to ${categoryText} according to <instructions>.
-
-Return a JSON object with a "labels" array containing exactly ${list.length} group names, one for each item in the same order as the input list.
-
-${instructionsBlock}
-${categoryBlock}${listBlock}
-
-Output format: {"labels": [array with exactly ${list.length} group names]}`;
-};
-
-export default async function listGroup(list, instructions, categories, config = {}) {
-  const { llm, ...options } = config;
-  const modelOptions = await createModelOptions(llm);
-  const output = await chatGPT(buildPrompt(list, instructions, categories), {
-    modelOptions,
-    ...options,
-  });
-
-  // With structured outputs, response should already be parsed and validated
-  let parsed;
-  if (typeof output === 'string') {
-    try {
-      parsed = JSON.parse(output);
-    } catch {
-      // Handle non-JSON responses (e.g., from mocks or fallback cases)
-      // Split by newlines and filter out empty lines
-      const lines = output
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-      parsed = { labels: lines };
-    }
-  } else {
-    parsed = output;
-  }
-
-  // Extract labels from the object structure
-  const labels = parsed?.labels || parsed;
-
-  if (!Array.isArray(labels) || labels.length !== list.length) {
-    console.warn(`Expected ${list.length} labels, got ${labels?.length || 0}`);
-    // Fallback to default labels if parsing fails
-    return { other: [...list] };
-  }
-
-  // Group items by their labels
-  const result = {};
-  labels.forEach((label, idx) => {
-    const key = String(label).trim() || 'other';
-    if (!result[key]) result[key] = [];
-    result[key].push(list[idx]);
-  });
-
-  return result;
-}

package/src/verblets/list-group/index.spec.js

@@ -1,35 +0,0 @@
-import listGroup from './index.js';
-import { vi, describe, it, expect } from 'vitest';
-
-vi.mock('../../lib/chatgpt/index.js', () => ({
-  default: vi.fn(() => 'odd\neven\nodd'),
-}));
-
-const examples = [
-  {
-    inputs: {
-      list: ['a', 'bb', 'ccc'],
-      instructions: 'odd or even length',
-      categories: ['odd', 'even'],
-    },
-    want: { result: { odd: ['a', 'ccc'], even: ['bb'] } },
-  },
-];
-
-describe('list-group verblet', () => {
-  it('groups items using instructions', async () => {
-    const result = await listGroup(['a', 'bb', 'ccc'], 'odd or even length', ['odd', 'even']);
-    expect(result).toStrictEqual({ odd: ['a', 'ccc'], even: ['bb'] });
-  });
-
-  examples.forEach((example) => {
-    it(example.inputs.instructions, async () => {
-      const result = await listGroup(
-        example.inputs.list,
-        example.inputs.instructions,
-        example.inputs.categories
-      );
-      expect(result).toStrictEqual(example.want.result);
-    });
-  });
-});

package/src/verblets/list-group/list-group-result.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "labels": {
-      "type": "array",
-      "description": "Array of group labels corresponding to input items in the same order",
-      "items": {
-        "type": "string",
-        "description": "Group label for the corresponding item"
-      }
-    }
-  },
-  "required": ["labels"],
-  "additionalProperties": false
-} 

package/src/verblets/list-map/README.md

@@ -1,11 +0,0 @@
-# list-map
-
-Transform a list with a single ChatGPT call by providing mapping instructions.
-The function hides the boilerplate prompting so you only supply the instructions.
-
-```javascript
-import { listMap } from '../../index.js';
-
-await listMap(['Budget smartphone', 'Luxury watch'], 'Write a short playful tagline');
-// => ['Affordable tech for everyone', 'Elegance that tells time']
-```

package/src/verblets/list-map/index.examples.js

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import listMap from './index.js';
-import { longTestTimeout } from '../../constants/common.js';
-
-describe('list-map examples', () => {
-  it(
-    'maps creative slogans',
-    async () => {
-      const items = ['smart toaster', 'robot vacuum'];
-      const result = await listMap(items, 'Give a playful marketing slogan');
-      expect(result.length).toBe(2);
-    },
-    longTestTimeout
-  );
-});

package/src/verblets/list-map/index.js

@@ -1,26 +0,0 @@
-import chatGPT from '../../lib/chatgpt/index.js';
-import wrapVariable from '../../prompts/wrap-variable.js';
-
-const buildPrompt = function (list, instructions) {
-  const instructionsBlock = wrapVariable(instructions, { tag: 'instructions' });
-  const listBlock = wrapVariable(list.join('\n'), { tag: 'list' });
-  return `For each line in <list>, apply the <instructions> to transform it.\nReturn the same number of lines without numbering.\n\n${instructionsBlock}\n${listBlock}`;
-};
-
-export default async function listMap(list, instructions, config = {}) {
-  const { llm, ...options } = config;
-  const output = await chatGPT(buildPrompt(list, instructions), {
-    modelOptions: { ...llm },
-    ...options,
-  });
-  const lines = output
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
-  if (lines.length !== list.length) {
-    throw new Error(
-      `Batch output line count mismatch (expected ${list.length}, got ${lines.length})`
-    );
-  }
-  return lines;
-}