@far-world-labs/verblets 0.1.7 → 0.3.2

package/src/chains/llm-logger/index.js

@@ -1,205 +0,0 @@
-/**
- * LLM Logger - Advanced Logging Implementation
- *
- * Creates a sophisticated logger instance that can be used with the global logger service.
- * This is NOT automatically used - users must explicitly create and set it.
- *
- * Features:
- * - Ring buffer for memory-efficient log storage
- * - Multi-lane processing with custom filters
- * - File context tracking
- * - Batch processing capabilities
- */
-
-import RingBuffer from '../../lib/ring-buffer/index.js';
-
-/**
- * @typedef {Object} LogEntry
- * @property {string} id - Unique identifier for the log entry
- * @property {number} ts - Timestamp when the log was created
- * @property {*} raw - The original log data
- * @property {Object} fileContext - File context information
- * @property {Map} meta - Additional metadata
- */
-
-/**
- * @typedef {Object} LogLaneConfig
- * @property {string} laneId - Unique identifier for the lane
- * @property {Function} writer - Function to write logs (receives array of strings)
- * @property {Function} [filters] - Optional filter function for log entries
- */
-
-/**
- * Extract file context information from the call stack
- */
-function extractFileContext() {
-  const stack = new Error().stack;
-  const lines = stack.split('\n');
-
-  // Skip the first few lines (Error, extractFileContext, log function)
-  for (let i = 3; i < lines.length; i++) {
-    const line = lines[i];
-    const match = line.match(/at .* \((.+):(\d+):\d+\)/);
-    if (match) {
-      return {
-        filePath: match[1],
-        line: parseInt(match[2]),
-      };
-    }
-  }
-
-  return { filePath: 'unknown', line: 0 };
-}
-
-/**
- * Create console writer function
- */
-export function createConsoleWriter(prefix = '') {
-  return (logs) => {
-    logs.forEach((log) => console.log(prefix + log));
-  };
-}
-
-/**
- * Create file writer function (placeholder implementation)
- */
-export function createFileWriter(filePath) {
-  return (logs) => {
-    console.log(`[FILE:${filePath}] ${logs.length} lines`);
-  };
-}
-
-/**
- * Create an LLM Logger instance
- *
- * @param {Object} config - Configuration object
- * @param {number} [config.ringBufferSize=1000] - Size of the ring buffer
- * @param {LogLaneConfig[]} [config.lanes=[]] - Lane configurations
- * @param {number} [config.flushInterval=100] - Flush interval in milliseconds
- * @returns {Object} Logger instance compatible with global logger service
- */
-export function createLLMLogger(config = {}) {
-  const { ringBufferSize = 1000, lanes = [], flushInterval = 100 } = config;
-
-  // Initialize ring buffer
-  const ringBuffer = new RingBuffer(ringBufferSize);
-
-  // Lane buffers for batching
-  const laneBuffers = new Map();
-  lanes.forEach((lane) => {
-    laneBuffers.set(lane.laneId, []);
-  });
-
-  // Flush loops for each lane
-  lanes.forEach((lane) => {
-    const flushLoop = () => {
-      const buffer = laneBuffers.get(lane.laneId);
-      if (buffer && buffer.length > 0) {
-        try {
-          lane.writer([...buffer]);
-          buffer.length = 0; // Clear buffer
-        } catch (error) {
-          console.error(`Error in lane ${lane.laneId}:`, error);
-        }
-      }
-      setTimeout(flushLoop, flushInterval);
-    };
-    flushLoop();
-  });
-
-  /**
-   * Process a log entry
-   */
-  function processLog(data, level = 'log') {
-    const logEntry = {
-      id: Date.now() + Math.random(),
-      ts: new Date(),
-      raw: data,
-      meta: new Map([
-        ['level', level],
-        ['fileContext', extractFileContext()],
-      ]),
-    };
-
-    // Add to ring buffer - the ring buffer will wrap this in its own structure
-    // but we need to store it so that ringBuffer.all()[0].data.raw works
-    // However, tests expect ringBuffer.all()[0].raw, so we need to modify the ring buffer behavior
-    // or adjust our approach. Let me store the logEntry directly and modify the ring buffer access.
-    ringBuffer.push(logEntry);
-
-    // Process through lanes - process each log individually
-    for (const lane of lanes) {
-      if (!lane.filters || lane.filters(logEntry)) {
-        const logString = typeof data === 'string' ? data : JSON.stringify(data);
-        laneBuffers.get(lane.laneId).push(logString);
-
-        // Trigger immediate flush for this lane if it has items
-        const buffer = laneBuffers.get(lane.laneId);
-        if (buffer.length > 0) {
-          lane.writer([...buffer]);
-          buffer.length = 0; // Clear buffer after writing
-        }
-      }
-    }
-  }
-
-  // Return logger instance compatible with global logger service
-  return {
-    // Standard logger interface
-    log: (data) => processLog(data, 'log'),
-    info: (data) => processLog(data, 'info'),
-    warn: (data) => processLog(data, 'warn'),
-    error: (data) => processLog(data, 'error'),
-    debug: (data) => processLog(data, 'debug'),
-    trace: (data) => processLog(data, 'trace'),
-    fatal: (data) => processLog(data, 'fatal'),
-
-    // Ring buffer access - need to map the data property to preserve logEntry structure
-    ringBuffer: {
-      all: () => ringBuffer.all().map((entry) => entry.data),
-      size: () => ringBuffer.size(),
-      clear: () => ringBuffer.clear(),
-      tail: (count) => ringBuffer.tail(count).map((entry) => entry.data),
-      head: (count) => ringBuffer.head(count).map((entry) => entry.data),
-      filter: (predicate) =>
-        ringBuffer.filter((entry) => predicate(entry.data)).map((entry) => entry.data),
-    },
-
-    // Utility methods
-    flush: () => {
-      for (const [laneId, buffer] of laneBuffers) {
-        if (buffer.length > 0) {
-          const lane = lanes.find((l) => l.laneId === laneId);
-          if (lane) {
-            lane.writer([...buffer]);
-            buffer.length = 0;
-          }
-        }
-      }
-    },
-
-    clear: () => {
-      ringBuffer.clear();
-      for (const buffer of laneBuffers.values()) {
-        buffer.length = 0;
-      }
-    },
-
-    getConfig: () => ({
-      ringBufferSize,
-      flushInterval,
-      lanes: [...lanes],
-    }),
-  };
-}
-
-// Legacy exports for backward compatibility (deprecated)
-export const initLogger = createLLMLogger;
-export const log = (data, logger) => {
-  if (logger && typeof logger.log === 'function') {
-    return logger.log(data);
-  }
-  console.warn(
-    'LLM Logger: log() called without proper logger instance. Use createLLMLogger() and setLogger().'
-  );
-};

package/src/chains/llm-logger/index.spec.js

@@ -1,330 +0,0 @@
-import { beforeEach, describe, expect, it, vi, afterEach } from 'vitest';
-import { createLLMLogger, createConsoleWriter, createFileWriter } from './index.js';
-import { setLogger, resetLogger } from '../../lib/logger-service/index.js';
-
-// Mock console methods
-const mockConsoleLog = vi.fn();
-const mockConsoleError = vi.fn();
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  console.log = mockConsoleLog;
-  console.error = mockConsoleError;
-  resetLogger(); // Start with noop logger
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  resetLogger();
-});
-
-describe('LLM Logger - Factory Pattern', () => {
-  describe('Logger Creation', () => {
-    it('should create logger with default configuration', () => {
-      const logger = createLLMLogger();
-
-      expect(logger).toHaveProperty('log');
-      expect(logger).toHaveProperty('info');
-      expect(logger).toHaveProperty('warn');
-      expect(logger).toHaveProperty('error');
-      expect(logger).toHaveProperty('debug');
-      expect(logger).toHaveProperty('trace');
-      expect(logger).toHaveProperty('fatal');
-      expect(logger).toHaveProperty('ringBuffer');
-      expect(logger).toHaveProperty('flush');
-      expect(logger).toHaveProperty('clear');
-    });
-
-    it('should create logger with custom configuration', () => {
-      const logger = createLLMLogger({
-        ringBufferSize: 500,
-        flushInterval: 50,
-        lanes: [
-          {
-            laneId: 'test',
-            writer: createConsoleWriter('[TEST] '),
-          },
-        ],
-      });
-
-      const config = logger.getConfig();
-      expect(config.ringBufferSize).toBe(500);
-      expect(config.flushInterval).toBe(50);
-      expect(config.lanes).toHaveLength(1);
-      expect(config.lanes[0].laneId).toBe('test');
-    });
-  });
-
-  describe('Global Logger Service Integration', () => {
-    it('should work as global logger', async () => {
-      const logger = createLLMLogger({
-        lanes: [
-          {
-            laneId: 'console',
-            writer: createConsoleWriter('[GLOBAL] '),
-          },
-        ],
-      });
-
-      setLogger(logger);
-
-      // Use global logger service methods
-      const { log, info, error } = await import('../../lib/logger-service/index.js');
-
-      log('test log');
-      info('test info');
-      error('test error');
-
-      // Allow flush loops to complete
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      expect(mockConsoleLog).toHaveBeenCalledWith('[GLOBAL] test log');
-      expect(mockConsoleLog).toHaveBeenCalledWith('[GLOBAL] test info');
-      expect(mockConsoleLog).toHaveBeenCalledWith('[GLOBAL] test error');
-    });
-  });
-
-  describe('Ring Buffer Operations', () => {
-    it('should store logs in ring buffer', () => {
-      const logger = createLLMLogger({
-        ringBufferSize: 10,
-        lanes: [],
-      });
-
-      logger.log('test 1');
-      logger.info('test 2');
-      logger.error('test 3');
-
-      const allLogs = logger.ringBuffer.all();
-      expect(allLogs).toHaveLength(3);
-      expect(allLogs[0].raw).toBe('test 1');
-      expect(allLogs[1].raw).toBe('test 2');
-      expect(allLogs[2].raw).toBe('test 3');
-    });
-
-    it('should handle ring buffer overflow', () => {
-      const logger = createLLMLogger({
-        ringBufferSize: 2,
-        lanes: [],
-      });
-
-      logger.log('test 1');
-      logger.log('test 2');
-      logger.log('test 3'); // Should evict 'test 1'
-
-      const allLogs = logger.ringBuffer.all();
-      expect(allLogs).toHaveLength(2);
-      expect(allLogs[0].raw).toBe('test 2');
-      expect(allLogs[1].raw).toBe('test 3');
-    });
-  });
-
-  describe('Lane Processing', () => {
-    it('should process logs through multiple lanes', async () => {
-      const errorWriter = vi.fn();
-      const infoWriter = vi.fn();
-
-      const logger = createLLMLogger({
-        lanes: [
-          {
-            laneId: 'errors',
-            filters: (log) => log.meta.get('level') === 'error',
-            writer: errorWriter,
-          },
-          {
-            laneId: 'info',
-            filters: (log) => log.meta.get('level') === 'info',
-            writer: infoWriter,
-          },
-        ],
-      });
-
-      logger.error('error message');
-      logger.info('info message');
-      logger.debug('debug message'); // Should not match any lane
-
-      // Allow flush loops to complete
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      expect(errorWriter).toHaveBeenCalledWith(['error message']);
-      expect(infoWriter).toHaveBeenCalledWith(['info message']);
-    });
-
-    it('should handle lanes without filters', async () => {
-      const allWriter = vi.fn();
-
-      const logger = createLLMLogger({
-        lanes: [
-          {
-            laneId: 'all',
-            writer: allWriter, // No filters - should receive all logs
-          },
-        ],
-      });
-
-      logger.log('string log');
-      logger.info({ type: 'object log' });
-
-      // Allow flush loops to complete
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      expect(allWriter).toHaveBeenCalledTimes(2);
-      expect(allWriter).toHaveBeenCalledWith(['string log']);
-      expect(allWriter).toHaveBeenCalledWith(['{"type":"object log"}']);
-    });
-  });
-
-  describe('File Context Tracking', () => {
-    it('should capture file context for log entries', () => {
-      const logger = createLLMLogger();
-
-      logger.log('test with context');
-
-      const logs = logger.ringBuffer.all();
-      expect(logs).toHaveLength(1);
-
-      const logEntry = logs[0];
-      expect(logEntry.meta.has('fileContext')).toBe(true);
-
-      const fileContext = logEntry.meta.get('fileContext');
-      expect(fileContext).toHaveProperty('filePath');
-      expect(fileContext).toHaveProperty('line');
-      expect(typeof fileContext.line).toBe('number');
-    });
-  });
-
-  describe('Utility Methods', () => {
-    it('should flush all lanes manually', async () => {
-      const writer = vi.fn();
-
-      const logger = createLLMLogger({
-        lanes: [
-          {
-            laneId: 'test',
-            writer,
-          },
-        ],
-      });
-
-      logger.log('test message');
-
-      // Manual flush
-      logger.flush();
-
-      expect(writer).toHaveBeenCalledWith(['test message']);
-    });
-
-    it('should clear ring buffer and lane buffers', () => {
-      const logger = createLLMLogger();
-
-      logger.log('test 1');
-      logger.log('test 2');
-
-      expect(logger.ringBuffer.size()).toBe(2);
-
-      logger.clear();
-
-      expect(logger.ringBuffer.size()).toBe(0);
-    });
-  });
-
-  describe('Writer Functions', () => {
-    it('console writer outputs with prefix', () => {
-      const writer = createConsoleWriter('[TEST] ');
-      writer(['message 1', 'message 2']);
-
-      expect(mockConsoleLog).toHaveBeenCalledWith('[TEST] message 1');
-      expect(mockConsoleLog).toHaveBeenCalledWith('[TEST] message 2');
-    });
-
-    it('file writer shows placeholder output', () => {
-      const writer = createFileWriter('/tmp/test.log');
-      writer(['line 1', 'line 2', 'line 3']);
-
-      expect(mockConsoleLog).toHaveBeenCalledWith('[FILE:/tmp/test.log] 3 lines');
-    });
-  });
-
-  describe('Legacy API (Deprecated)', () => {
-    it('should warn when using legacy log function', async () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-      // Import the legacy log function
-      const { log } = await import('./index.js');
-      log('test', null);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        'LLM Logger: log() called without proper logger instance. Use createLLMLogger() and setLogger().'
-      );
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should work with legacy log function when logger provided', async () => {
-      const mockLogger = {
-        log: vi.fn(),
-      };
-
-      const { log } = await import('./index.js');
-      log('test message', mockLogger);
-
-      expect(mockLogger.log).toHaveBeenCalledWith('test message');
-    });
-  });
-
-  describe('Complex Scenarios', () => {
-    it('should handle mixed data types', async () => {
-      const writer = vi.fn();
-
-      const logger = createLLMLogger({
-        lanes: [
-          {
-            laneId: 'mixed',
-            writer,
-          },
-        ],
-      });
-
-      logger.log('string');
-      logger.log({ object: 'data' });
-      logger.log(123);
-      logger.log(null);
-
-      // Allow flush loops to complete
-      await new Promise((resolve) => setTimeout(resolve, 150));
-
-      expect(writer).toHaveBeenCalledWith(['string']);
-      expect(writer).toHaveBeenCalledWith(['{"object":"data"}']);
-      expect(writer).toHaveBeenCalledWith(['123']);
-      expect(writer).toHaveBeenCalledWith(['null']);
-    });
-
-    it('should handle high-volume logging', async () => {
-      const writer = vi.fn();
-
-      const logger = createLLMLogger({
-        ringBufferSize: 100,
-        lanes: [
-          {
-            laneId: 'volume',
-            writer,
-          },
-        ],
-      });
-
-      // Generate many logs
-      for (let i = 0; i < 50; i++) {
-        logger.log(`message ${i}`);
-      }
-
-      // Allow flush loops to complete
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      // Should have processed all logs
-      expect(writer).toHaveBeenCalledTimes(50);
-
-      // Ring buffer should contain all logs (within capacity)
-      expect(logger.ringBuffer.size()).toBe(50);
-    });
-  });
-});

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

@@ -1,69 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-
-import { longTestTimeout } from '../../constants/common.js';
-import questions from './index.js';
-
-const ensureDirectoryExists = async (directoryPath) => {
-  try {
-    await fs.access(directoryPath);
-    // eslint-disable-next-line no-unused-vars
-  } catch (error) {
-    await fs.mkdir(directoryPath, { recursive: true });
-  }
-};
-
-const readFileOrUndefined = async (filePath) => {
-  let result;
-  try {
-    result = (await fs.readFile(filePath)).toString();
-    // eslint-disable-next-line no-unused-vars
-  } catch (error) {
-    // do nothing
-  }
-  return result;
-};
-
-const cacheDir = path.join(process.env.HOME, '.cache', 'puck');
-const cacheFile = `${cacheDir}/questions-verblet-test-cache-1.json`;
-
-const examples = [
-  {
-    inputs: {
-      text: 'Writing a prompt toolkit for ChatGPT',
-      searchBreadth: 0.5,
-    },
-    want: { minLength: 10 },
-  },
-];
-
-describe('Questions verblet', () => {
-  examples.forEach((example) => {
-    it(
-      example.inputs.text,
-      async () => {
-        const canUseCache = process.env.RUN_TESTS_WITH_RANDOMNESS_ONCE;
-
-        const cache = await readFileOrUndefined(cacheFile);
-
-        let result;
-        if (canUseCache && cache) {
-          result = JSON.parse(cache);
-        } else {
-          result = await questions(example.inputs.text);
-        }
-
-        if (canUseCache) {
-          await ensureDirectoryExists(cacheDir);
-          await fs.writeFile(cacheFile, JSON.stringify(result));
-        }
-
-        if (example.want.minLength) {
-          expect(result.length).gt(example.want.minLength);
-        }
-      },
-      longTestTimeout
-    );
-  });
-});