feat: add structured pino logger in core, CacheManager.resetInstance(), and tests

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/ai/__tests__/unit/cache-manager-isolation.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { CacheManager } from '../../src/cache-manager';
+
+describe('CacheManager — resetInstance test isolation', () => {
+  afterEach(() => {
+    CacheManager.resetInstance();
+  });
+
+  it('should fully reset singleton so next getInstance creates fresh instance', async () => {
+    const cm1 = CacheManager.getInstance();
+    await cm1.set('key', 'value', 60);
+    expect(await cm1.get('key')).toBe('value');
+
+    CacheManager.resetInstance();
+
+    const cm2 = CacheManager.getInstance();
+    // After reset, the new instance should have an empty cache
+    expect(await cm2.get('key')).toBeNull();
+    expect(cm2.getStats().size).toBe(0);
+  });
+
+  it('should allow a different config after reset', () => {
+    const cm1 = CacheManager.getInstance({ defaultTtl: 300 });
+    CacheManager.resetInstance();
+
+    const cm2 = CacheManager.getInstance({ defaultTtl: 600 });
+    // Should be a brand new instance (not same reference as cm1)
+    expect(cm2).not.toBe(cm1);
+  });
+
+  it('should not throw when called before any getInstance', () => {
+    // Fresh state — no instance exists yet
+    expect(() => CacheManager.resetInstance()).not.toThrow();
+  });
+
+  it('should not throw when called twice in a row', () => {
+    CacheManager.getInstance();
+    CacheManager.resetInstance();
+    expect(() => CacheManager.resetInstance()).not.toThrow();
+  });
+
+  it('should isolate cache state between test runs', async () => {
+    // Simulate test A
+    const cmA = CacheManager.getInstance();
+    await cmA.set('shared', 'from-test-a', 60);
+    CacheManager.resetInstance();
+
+    // Simulate test B — should not see test A's data
+    const cmB = CacheManager.getInstance();
+    expect(await cmB.get('shared')).toBeNull();
+  });
+});

packages/ai/src/cache-manager.ts

@@ -57,6 +57,19 @@ export class CacheManager {
     return CacheManager.instance;
   }
 
+  /**
+   * Reset singleton instance for test isolation.
+   * Call in beforeEach/afterEach to ensure a clean slate between tests.
+   */
+  static resetInstance(): void {
+    if (CacheManager.instance) {
+      CacheManager.instance.memoryCache.clear();
+      CacheManager.instance.redisClient = null;
+      CacheManager.instance.useRedis = false;
+    }
+    CacheManager.instance = undefined as unknown as CacheManager;
+  }
+  
   /**
    * Initialize Redis client
    */

packages/core/__tests__/unit/logger.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createLogger, logger } from '../../src/logger';
+
+describe('Logger', () => {
+  const originalEnv = process.env.LOG_LEVEL;
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env.LOG_LEVEL;
+    } else {
+      process.env.LOG_LEVEL = originalEnv;
+    }
+  });
+
+  describe('createLogger', () => {
+    it('should create a logger with the specified module name', () => {
+      const log = createLogger('crm:account');
+      // pino exposes bindings() which includes "name"
+      expect((log as any).bindings().name).toBe('crm:account');
+    });
+
+    it('should default to info level', () => {
+      const log = createLogger('test:module');
+      expect(log.level).toBe('info');
+    });
+
+    it('should accept a custom level via options', () => {
+      const log = createLogger('test:debug', { level: 'debug' });
+      expect(log.level).toBe('debug');
+    });
+
+    it('should respect LOG_LEVEL env variable', () => {
+      process.env.LOG_LEVEL = 'warn';
+      const log = createLogger('test:env');
+      expect(log.level).toBe('warn');
+    });
+
+    it('should prefer explicit option over env variable', () => {
+      process.env.LOG_LEVEL = 'warn';
+      const log = createLogger('test:override', { level: 'error' });
+      expect(log.level).toBe('error');
+    });
+  });
+
+  describe('logger (default instance)', () => {
+    it('should be a valid pino logger', () => {
+      expect(typeof logger.info).toBe('function');
+      expect(typeof logger.warn).toBe('function');
+      expect(typeof logger.error).toBe('function');
+      expect(typeof logger.debug).toBe('function');
+    });
+
+    it('should have name "hotcrm"', () => {
+      expect((logger as any).bindings().name).toBe('hotcrm');
+    });
+  });
+
+  describe('structured output', () => {
+    it('should produce JSON output with structured data', () => {
+      const chunks: string[] = [];
+      const dest = {
+        write(chunk: string) { chunks.push(chunk); },
+      } as any;
+
+      // Create a pino logger writing to our mock destination
+      const pino = require('pino');
+      const log = pino({ name: 'test:json', level: 'info' }, dest);
+      log.info({ accountId: '123', score: 85 }, 'Account scored');
+
+      expect(chunks.length).toBe(1);
+      const parsed = JSON.parse(chunks[0]);
+      expect(parsed.name).toBe('test:json');
+      expect(parsed.accountId).toBe('123');
+      expect(parsed.score).toBe(85);
+      expect(parsed.msg).toBe('Account scored');
+      expect(parsed.level).toBe(30); // pino info = 30
+    });
+
+    it('should not contain emoji in structured output', () => {
+      const chunks: string[] = [];
+      const dest = {
+        write(chunk: string) { chunks.push(chunk); },
+      } as any;
+
+      const pino = require('pino');
+      const log = pino({ name: 'test:no-emoji', level: 'info' }, dest);
+      log.info('Account created successfully');
+
+      const parsed = JSON.parse(chunks[0]);
+      // Verify no emoji characters (common emoji ranges)
+      const emojiRegex = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/u;
+      expect(emojiRegex.test(parsed.msg)).toBe(false);
+    });
+  });
+});

packages/core/src/index.ts

@@ -1,3 +1,5 @@
 // Core platform exports
 export const VERSION = '1.0.0';
 export * from './zod-helper.js';
+export { createLogger, logger } from './logger.js';
+export type { LogLevel, LoggerOptions } from './logger.js';

packages/core/src/logger.ts

@@ -0,0 +1,35 @@
+/**
+ * Structured Logger — pino-based logging for HotCRM
+ *
+ * Provides leveled, machine-parseable logging (debug/info/warn/error).
+ * All hook, action, and service files should use this instead of console.log.
+ *
+ * Usage:
+ *   import { createLogger } from '@hotcrm/core';
+ *   const logger = createLogger('crm:account');
+ *   logger.info({ accountId }, 'Account created');
+ *   logger.error({ err }, 'Failed to update account');
+ */
+
+import pino from 'pino';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
+
+export interface LoggerOptions {
+  /** Minimum log level (default: from LOG_LEVEL env or 'info') */
+  level?: LogLevel;
+}
+
+/**
+ * Create a child logger scoped to a specific module.
+ *
+ * @param module  Hierarchical module name, e.g. 'crm:account' or 'ai:cache'
+ * @param options Optional overrides
+ */
+export function createLogger(module: string, options?: LoggerOptions): pino.Logger {
+  const level = options?.level ?? (process.env.LOG_LEVEL as LogLevel) ?? 'info';
+  return pino({ name: module, level });
+}
+
+/** Shared root logger instance */
+export const logger: pino.Logger = createLogger('hotcrm');