@soleri/core 2.1.0 → 2.5.0

package/src/__tests__/intake-pipeline.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { dedupItems, DEDUP_THRESHOLD } from '../intake/dedup-gate.js';
+import { Vault } from '../vault/vault.js';
+import type { ClassifiedItem } from '../intake/types.js';
+
+function makeItem(overrides: Partial<ClassifiedItem> = {}): ClassifiedItem {
+  return {
+    type: overrides.type ?? 'pattern',
+    title: overrides.title ?? 'Test Pattern',
+    description: overrides.description ?? 'A generic test description.',
+    tags: overrides.tags ?? ['test'],
+    severity: overrides.severity ?? 'suggestion',
+    citation: overrides.citation ?? 'p.1',
+  };
+}
+
+describe('Dedup Gate', () => {
+  let vault: Vault;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+  });
+
+  afterEach(() => {
+    vault.close();
+  });
+
+  it('should mark items as non-duplicate when vault is empty', () => {
+    const items: ClassifiedItem[] = [
+      makeItem({ title: 'Brand New Pattern', description: 'Something entirely new.' }),
+    ];
+
+    const results = dedupItems(items, vault);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isDuplicate).toBe(false);
+    expect(results[0].similarity).toBe(0);
+    expect(results[0].bestMatchId).toBeUndefined();
+    expect(results[0].item).toBe(items[0]);
+  });
+
+  it('should detect near-duplicates with high similarity', () => {
+    vault.seed([
+      {
+        id: 'existing-1',
+        type: 'pattern',
+        domain: 'design-patterns',
+        title: 'Singleton Pattern Implementation',
+        severity: 'suggestion',
+        description:
+          'The singleton pattern ensures a class has only one instance and provides a global point of access to it.',
+        tags: ['singleton', 'design-pattern', 'creational'],
+      },
+    ]);
+
+    const items: ClassifiedItem[] = [
+      makeItem({
+        title: 'Singleton Pattern Implementation',
+        description:
+          'The singleton pattern ensures a class has only one instance and provides a global point of access to it.',
+        tags: ['singleton', 'design-pattern', 'creational'],
+      }),
+    ];
+
+    const results = dedupItems(items, vault);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].similarity).toBeGreaterThan(0.5);
+    expect(results[0].bestMatchId).toBe('existing-1');
+  });
+
+  it('should not flag dissimilar entries as duplicates', () => {
+    vault.seed([
+      {
+        id: 'existing-2',
+        type: 'pattern',
+        domain: 'design-patterns',
+        title: 'Observer Pattern',
+        severity: 'suggestion',
+        description:
+          'The observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.',
+        tags: ['observer', 'design-pattern', 'behavioral'],
+      },
+    ]);
+
+    const items: ClassifiedItem[] = [
+      makeItem({
+        title: 'God Object Anti-Pattern',
+        description:
+          'A god object is an anti-pattern where a single class knows too much or does too much, violating the single responsibility principle.',
+        tags: ['anti-pattern', 'code-smell'],
+      }),
+    ];
+
+    const results = dedupItems(items, vault);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isDuplicate).toBe(false);
+  });
+
+  it('should handle multiple items at once', () => {
+    vault.seed([
+      {
+        id: 'existing-3',
+        type: 'pattern',
+        domain: 'design-patterns',
+        title: 'Factory Method Pattern',
+        severity: 'suggestion',
+        description:
+          'The factory method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate.',
+        tags: ['factory', 'design-pattern', 'creational'],
+      },
+    ]);
+
+    const items: ClassifiedItem[] = [
+      // Near-duplicate of vault entry
+      makeItem({
+        title: 'Factory Method Pattern',
+        description:
+          'The factory method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate.',
+        tags: ['factory', 'design-pattern', 'creational'],
+      }),
+      // Completely different
+      makeItem({
+        title: 'Dependency Injection',
+        description:
+          'Dependency injection is a technique where an object receives other objects that it depends on, called dependencies, rather than creating them internally.',
+        tags: ['dependency-injection', 'inversion-of-control'],
+      }),
+      // Also different
+      makeItem({
+        title: 'Circuit Breaker Pattern',
+        description:
+          'The circuit breaker pattern prevents an application from repeatedly trying to execute an operation that is likely to fail, allowing it to recover gracefully.',
+        tags: ['resilience', 'distributed-systems'],
+      }),
+    ];
+
+    const results = dedupItems(items, vault);
+
+    expect(results).toHaveLength(3);
+
+    // First item is a near-duplicate — should have high similarity
+    expect(results[0].similarity).toBeGreaterThan(0.5);
+    expect(results[0].bestMatchId).toBe('existing-3');
+
+    // Second and third items are different — should not be duplicates
+    expect(results[1].isDuplicate).toBe(false);
+    expect(results[2].isDuplicate).toBe(false);
+  });
+
+  it('DEDUP_THRESHOLD should be 0.85', () => {
+    expect(DEDUP_THRESHOLD).toBe(0.85);
+  });
+});
+
+describe('Intake Types', () => {
+  it('should import all type definitions', async () => {
+    const types = await import('../intake/types.js');
+    expect(types).toBeDefined();
+  });
+});

package/src/__tests__/intent-router.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { IntentRouter } from '../control/intent-router.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OperationalMode } from '../control/types.js';
+
+describe('IntentRouter', () => {
+  let runtime: AgentRuntime;
+  let router: IntentRouter;
+  let plannerDir: string;
+
+  beforeEach(() => {
+    plannerDir = join(tmpdir(), 'intent-test-' + Date.now());
+    mkdirSync(plannerDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'intent-test',
+      vaultPath: ':memory:',
+      plansPath: join(plannerDir, 'plans.json'),
+    });
+    router = new IntentRouter(runtime.vault);
+  });
+
+  afterEach(() => {
+    runtime.close();
+    rmSync(plannerDir, { recursive: true, force: true });
+  });
+
+  // ─── Default Modes ──────────────────────────────────────────────────
+
+  it('should seed 10 default modes', () => {
+    const modes = router.getModes();
+    expect(modes).toHaveLength(10);
+  });
+
+  it('should include all expected modes', () => {
+    const modeNames = router.getModes().map((m) => m.mode);
+    expect(modeNames).toContain('BUILD-MODE');
+    expect(modeNames).toContain('FIX-MODE');
+    expect(modeNames).toContain('VALIDATE-MODE');
+    expect(modeNames).toContain('DESIGN-MODE');
+    expect(modeNames).toContain('IMPROVE-MODE');
+    expect(modeNames).toContain('DELIVER-MODE');
+    expect(modeNames).toContain('EXPLORE-MODE');
+    expect(modeNames).toContain('PLAN-MODE');
+    expect(modeNames).toContain('REVIEW-MODE');
+    expect(modeNames).toContain('GENERAL-MODE');
+  });
+
+  it('should start in GENERAL-MODE', () => {
+    expect(router.getCurrentMode()).toBe('GENERAL-MODE');
+  });
+
+  // ─── Intent Classification ──────────────────────────────────────────
+
+  it('should route "fix this bug" to FIX-MODE', () => {
+    const result = router.routeIntent('fix this bug');
+    expect(result.intent).toBe('fix');
+    expect(result.mode).toBe('FIX-MODE');
+    expect(result.confidence).toBeGreaterThan(0);
+    expect(result.method).toBe('keyword');
+    expect(result.matchedKeywords).toContain('fix');
+    expect(result.matchedKeywords).toContain('bug');
+  });
+
+  it('should route "build a new feature" to BUILD-MODE', () => {
+    const result = router.routeIntent('build a new feature');
+    expect(result.intent).toBe('build');
+    expect(result.mode).toBe('BUILD-MODE');
+    expect(result.matchedKeywords).toContain('build');
+    expect(result.matchedKeywords).toContain('new');
+    expect(result.matchedKeywords).toContain('feature');
+  });
+
+  it('should route "refactor the auth module" to IMPROVE-MODE', () => {
+    const result = router.routeIntent('refactor the auth module');
+    expect(result.intent).toBe('improve');
+    expect(result.mode).toBe('IMPROVE-MODE');
+  });
+
+  it('should route "deploy to production" to DELIVER-MODE', () => {
+    const result = router.routeIntent('deploy to production');
+    expect(result.intent).toBe('deliver');
+    expect(result.mode).toBe('DELIVER-MODE');
+  });
+
+  it('should route "review this code" to REVIEW-MODE', () => {
+    const result = router.routeIntent('review this code');
+    expect(result.intent).toBe('review');
+    expect(result.mode).toBe('REVIEW-MODE');
+  });
+
+  it('should route "plan the architect strategy" to PLAN-MODE', () => {
+    const result = router.routeIntent('plan the architect strategy');
+    expect(result.intent).toBe('plan');
+    expect(result.mode).toBe('PLAN-MODE');
+    expect(result.matchedKeywords).toContain('plan');
+    expect(result.matchedKeywords).toContain('architect');
+    expect(result.matchedKeywords).toContain('strategy');
+  });
+
+  it('should fall back to GENERAL-MODE for unrecognized input', () => {
+    const result = router.routeIntent('hello there how are you');
+    expect(result.intent).toBe('general');
+    expect(result.mode).toBe('GENERAL-MODE');
+    expect(result.confidence).toBe(0);
+    expect(result.matchedKeywords).toEqual([]);
+  });
+
+  it('should update current mode after routing', () => {
+    router.routeIntent('fix this bug');
+    expect(router.getCurrentMode()).toBe('FIX-MODE');
+  });
+
+  it('should handle case-insensitive matching', () => {
+    const result = router.routeIntent('FIX this BUG');
+    expect(result.intent).toBe('fix');
+    expect(result.mode).toBe('FIX-MODE');
+  });
+
+  it('should cap confidence at 1.0', () => {
+    const result = router.routeIntent('fix bug broken error crash issue debug repair janky');
+    expect(result.confidence).toBeLessThanOrEqual(1.0);
+  });
+
+  // ─── Mode Management ───────────────────────────────────────────────
+
+  it('should morph to a specified mode', () => {
+    const result = router.morph('BUILD-MODE');
+    expect(result.previousMode).toBe('GENERAL-MODE');
+    expect(result.currentMode).toBe('BUILD-MODE');
+    expect(result.behaviorRules.length).toBeGreaterThan(0);
+    expect(router.getCurrentMode()).toBe('BUILD-MODE');
+  });
+
+  it('should throw on morph to unknown mode', () => {
+    expect(() => router.morph('UNKNOWN-MODE' as OperationalMode)).toThrow('Unknown mode');
+  });
+
+  it('should get behavior rules for current mode', () => {
+    router.morph('FIX-MODE');
+    const rules = router.getBehaviorRules();
+    expect(rules).toContain('Identify root cause first');
+  });
+
+  it('should get behavior rules for a specific mode', () => {
+    const rules = router.getBehaviorRules('DESIGN-MODE');
+    expect(rules).toContain('Use semantic tokens');
+  });
+
+  it('should return empty rules for unknown mode', () => {
+    const rules = router.getBehaviorRules('NONEXISTENT' as OperationalMode);
+    expect(rules).toEqual([]);
+  });
+
+  // ─── Custom Modes ──────────────────────────────────────────────────
+
+  it('should register a custom mode', () => {
+    router.registerMode({
+      mode: 'CUSTOM-MODE' as OperationalMode,
+      intent: 'general' as const,
+      description: 'Custom test mode',
+      behaviorRules: ['Custom rule'],
+      keywords: ['custom', 'special'],
+    });
+    const modes = router.getModes();
+    expect(modes.length).toBe(11);
+    const custom = modes.find((m) => m.mode === 'CUSTOM-MODE');
+    expect(custom).toBeDefined();
+    expect(custom!.keywords).toContain('custom');
+  });
+
+  it('should route to custom mode', () => {
+    router.registerMode({
+      mode: 'CUSTOM-MODE' as OperationalMode,
+      intent: 'general' as const,
+      description: 'Custom test mode',
+      behaviorRules: ['Custom rule'],
+      keywords: ['custom', 'special'],
+    });
+    const result = router.routeIntent('do something custom and special');
+    expect(result.mode).toBe('CUSTOM-MODE');
+  });
+
+  it('should update mode rules', () => {
+    router.updateModeRules('BUILD-MODE', ['New rule 1', 'New rule 2']);
+    const rules = router.getBehaviorRules('BUILD-MODE');
+    expect(rules).toEqual(['New rule 1', 'New rule 2']);
+  });
+
+  it('should throw on updating unknown mode rules', () => {
+    expect(() => router.updateModeRules('NONEXISTENT' as OperationalMode, ['Rule'])).toThrow(
+      'Unknown mode',
+    );
+  });
+
+  // ─── Analytics ──────────────────────────────────────────────────────
+
+  it('should track routing stats', () => {
+    router.routeIntent('fix this bug');
+    router.routeIntent('build a feature');
+    router.routeIntent('fix another error');
+    router.routeIntent('hello there');
+
+    const stats = router.getRoutingStats();
+    expect(stats.totalRouted).toBe(4);
+    expect(stats.byIntent.fix).toBe(2);
+    expect(stats.byIntent.build).toBe(1);
+    expect(stats.byIntent.general).toBe(1);
+    expect(stats.byMode['FIX-MODE']).toBe(2);
+    expect(stats.byMode['BUILD-MODE']).toBe(1);
+  });
+
+  it('should return empty stats initially', () => {
+    const stats = router.getRoutingStats();
+    expect(stats.totalRouted).toBe(0);
+    expect(stats.byIntent).toEqual({});
+    expect(stats.byMode).toEqual({});
+  });
+});

package/src/__tests__/logger.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { Logger, createLogger } from '../logging/logger.js';
+
+describe('Logger', () => {
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.SOLERI_LOG_LEVEL;
+  });
+
+  it('should default to info level', () => {
+    const logger = createLogger();
+    logger.debug('hidden');
+    logger.info('visible');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith('[Soleri][INFO] visible');
+  });
+
+  it('should suppress messages below configured level', () => {
+    const logger = createLogger({ level: 'warn' });
+    logger.debug('d');
+    logger.info('i');
+    logger.warn('w');
+    logger.error('e');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1); // error
+    expect(warnSpy).toHaveBeenCalledTimes(1); // warn
+    expect(warnSpy).toHaveBeenCalledWith('[Soleri][WARN] w');
+    expect(errorSpy).toHaveBeenCalledWith('[Soleri][ERROR] e');
+  });
+
+  it('should output everything at debug level', () => {
+    const logger = createLogger({ level: 'debug' });
+    logger.debug('d');
+    logger.info('i');
+    logger.warn('w');
+    logger.error('e');
+
+    // debug, info, error go through console.error; warn goes through console.warn
+    expect(errorSpy).toHaveBeenCalledTimes(3);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should route all output to stderr (not stdout)', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const logger = createLogger({ level: 'debug' });
+    logger.debug('d');
+    logger.info('i');
+    logger.warn('w');
+    logger.error('e');
+
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it('should use custom prefix', () => {
+    const logger = createLogger({ prefix: '[my-agent]' });
+    logger.info('hello');
+
+    expect(errorSpy).toHaveBeenCalledWith('[my-agent][INFO] hello');
+  });
+
+  it('should include context in log output', () => {
+    const logger = createLogger();
+    logger.info('msg', { key: 'value' });
+
+    expect(errorSpy).toHaveBeenCalledWith('[Soleri][INFO] msg', { key: 'value' });
+  });
+
+  it('should respect SOLERI_LOG_LEVEL env var', () => {
+    process.env.SOLERI_LOG_LEVEL = 'error';
+    const logger = createLogger();
+    logger.info('hidden');
+    logger.error('visible');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith('[Soleri][ERROR] visible');
+  });
+
+  it('should prefer explicit level over env var', () => {
+    process.env.SOLERI_LOG_LEVEL = 'error';
+    const logger = createLogger({ level: 'debug' });
+    logger.debug('visible');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should fall back to info level for invalid SOLERI_LOG_LEVEL', () => {
+    process.env.SOLERI_LOG_LEVEL = 'verbose'; // invalid
+    const logger = createLogger();
+    logger.debug('hidden');
+    logger.info('visible');
+
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith('[Soleri][INFO] visible');
+  });
+
+  it('createLogger with no args returns a Logger instance', () => {
+    const logger = createLogger();
+    expect(logger).toBeInstanceOf(Logger);
+  });
+});
+
+describe('Logger file logging', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    tempDir = join(tmpdir(), `logger-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should create log directory and write log files', () => {
+    const logDir = join(tempDir, 'logs');
+    const logger = createLogger({ fileLogDir: logDir });
+    logger.info('test message');
+
+    const logFiles = readdirSync(logDir).filter((f) => f.endsWith('.log'));
+    expect(logFiles.length).toBe(1);
+    expect(logFiles[0]).toMatch(/^agent-\d{4}-\d{2}-\d{2}\.log$/);
+
+    const content = readFileSync(join(logDir, logFiles[0]), 'utf-8');
+    expect(content).toContain('[INFO] test message');
+  });
+
+  it('should include context in file output', () => {
+    const logDir = join(tempDir, 'logs');
+    const logger = createLogger({ fileLogDir: logDir });
+    logger.info('event', { action: 'test' });
+
+    const logFile = readdirSync(logDir).find((f) => f.endsWith('.log'));
+    expect(logFile).toBeDefined();
+    const content = readFileSync(join(logDir, logFile!), 'utf-8');
+    expect(content).toContain('"action":"test"');
+  });
+
+  it('enableFileLog with custom prefix uses that prefix', () => {
+    const logDir = join(tempDir, 'logs');
+    const logger = createLogger();
+    logger.enableFileLog(logDir, 'custom');
+    logger.info('test');
+
+    const logFile = readdirSync(logDir).find((f) => f.endsWith('.log'));
+    expect(logFile).toBeDefined();
+    expect(logFile).toMatch(/^custom-/);
+  });
+
+  it('should prune log files older than 7 days', () => {
+    const logDir = join(tempDir, 'logs');
+    mkdirSync(logDir, { recursive: true });
+
+    // Create an "old" log file (10 days ago)
+    const oldDate = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    writeFileSync(join(logDir, `agent-${oldDate}.log`), 'old log\n');
+
+    // Create a "recent" log file (2 days ago)
+    const recentDate = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    writeFileSync(join(logDir, `agent-${recentDate}.log`), 'recent log\n');
+
+    // enableFileLog triggers pruning
+    const logger = createLogger();
+    logger.enableFileLog(logDir);
+
+    const files = readdirSync(logDir).filter((f) => f.endsWith('.log'));
+
+    // Old file should be pruned, recent + today should remain
+    expect(files).not.toContain(`agent-${oldDate}.log`);
+    expect(files).toContain(`agent-${recentDate}.log`);
+  });
+
+  it('should not prune files from different prefix', () => {
+    const logDir = join(tempDir, 'logs');
+    mkdirSync(logDir, { recursive: true });
+
+    const oldDate = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    writeFileSync(join(logDir, `other-${oldDate}.log`), 'other log\n');
+
+    const logger = createLogger();
+    logger.enableFileLog(logDir);
+
+    const files = readdirSync(logDir).filter((f) => f.endsWith('.log'));
+    expect(files).toContain(`other-${oldDate}.log`);
+  });
+});