@soleri/core 9.0.4 → 9.3.0

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

@@ -1,162 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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__/knowledge-review.test.ts

@@ -1,104 +0,0 @@
-/**
- * Knowledge Review Tests — team review workflows.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { Vault } from '../vault/vault.js';
-import { KnowledgeReview } from '../vault/knowledge-review.js';
-import type { IntelligenceEntry } from '../intelligence/types.js';
-
-describe('KnowledgeReview', () => {
-  let vault: Vault;
-  let review: KnowledgeReview;
-
-  const entry: IntelligenceEntry = {
-    id: 'test-entry-1',
-    type: 'pattern',
-    domain: 'testing',
-    title: 'Test Pattern',
-    severity: 'suggestion',
-    description: 'A test pattern',
-    tags: ['test'],
-  };
-
-  beforeEach(() => {
-    vault = new Vault(':memory:');
-    vault.seed([entry]);
-    review = new KnowledgeReview(vault.getProvider());
-  });
-
-  afterEach(() => {
-    vault.close();
-  });
-
-  test('submit transitions to pending_review', () => {
-    const result = review.submit({ entryId: 'test-entry-1', submittedBy: 'alice' });
-    expect(result.status).toBe('pending_review');
-    expect(result.submittedBy).toBe('alice');
-    expect(result.submittedAt).toBeGreaterThan(0);
-  });
-
-  test('approve transitions from pending_review to approved', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    const result = review.approve({
-      entryId: 'test-entry-1',
-      reviewedBy: 'bob',
-      comment: 'Looks good',
-    });
-    expect(result.status).toBe('approved');
-    expect(result.reviewedBy).toBe('bob');
-    expect(result.reviewComment).toBe('Looks good');
-  });
-
-  test('reject transitions from pending_review to rejected', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    const result = review.reject({
-      entryId: 'test-entry-1',
-      reviewedBy: 'bob',
-      comment: 'Needs work',
-    });
-    expect(result.status).toBe('rejected');
-    expect(result.reviewComment).toBe('Needs work');
-  });
-
-  test('cannot approve non-pending entry', () => {
-    expect(() => review.approve({ entryId: 'test-entry-1' })).toThrow('not pending review');
-  });
-
-  test('cannot submit already pending entry', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    expect(() => review.submit({ entryId: 'test-entry-1' })).toThrow('cannot be submitted');
-  });
-
-  test('rejected entries can be resubmitted', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    review.reject({ entryId: 'test-entry-1' });
-    const result = review.submit({ entryId: 'test-entry-1', submittedBy: 'alice' });
-    expect(result.status).toBe('pending_review');
-  });
-
-  test('listPending returns pending entries', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    const pending = review.listPending();
-    expect(pending).toHaveLength(1);
-    expect(pending[0].entryId).toBe('test-entry-1');
-  });
-
-  test('stats returns counts by status', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    const stats = review.stats();
-    expect(stats.total).toBe(1);
-    expect(stats.byStatus.pending_review).toBe(1);
-  });
-
-  test('remove deletes review record', () => {
-    review.submit({ entryId: 'test-entry-1' });
-    const removed = review.remove('test-entry-1');
-    expect(removed).toBe(true);
-    expect(review.get('test-entry-1')).toBeNull();
-  });
-
-  test('get returns null for unknown entry', () => {
-    expect(review.get('nonexistent')).toBeNull();
-  });
-});

package/src/__tests__/llm-client.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { LLMClient } from '../llm/llm-client.js';
-import { KeyPool } from '../llm/key-pool.js';
-
-describe('LLMClient', () => {
-  it('should create with empty key pools', () => {
-    const openai = new KeyPool({ keys: [] });
-    const anthropic = new KeyPool({ keys: [] });
-    const client = new LLMClient(openai, anthropic);
-
-    expect(client.isAvailable()).toEqual({ openai: false, anthropic: false });
-  });
-
-  it('should report availability when keys present', () => {
-    const openai = new KeyPool({ keys: ['sk-test'] });
-    const anthropic = new KeyPool({ keys: ['sk-ant-test'] });
-    const client = new LLMClient(openai, anthropic);
-
-    expect(client.isAvailable()).toEqual({ openai: true, anthropic: true });
-  });
-
-  it('should accept agentId parameter', () => {
-    const openai = new KeyPool({ keys: [] });
-    const anthropic = new KeyPool({ keys: [] });
-    // Should not throw — agentId is used for model routing config
-    const client = new LLMClient(openai, anthropic, 'test-agent');
-    expect(client.isAvailable()).toEqual({ openai: false, anthropic: false });
-  });
-
-  it('should return empty routes by default', () => {
-    const openai = new KeyPool({ keys: [] });
-    const anthropic = new KeyPool({ keys: [] });
-    const client = new LLMClient(openai, anthropic);
-
-    expect(client.getRoutes()).toEqual([]);
-  });
-
-  it('should throw on callOpenAI without keys', async () => {
-    const openai = new KeyPool({ keys: [] });
-    const anthropic = new KeyPool({ keys: [] });
-    const client = new LLMClient(openai, anthropic);
-
-    await expect(
-      client.complete({
-        provider: 'openai',
-        model: 'gpt-4o-mini',
-        systemPrompt: 'test',
-        userPrompt: 'test',
-        caller: 'test',
-      }),
-    ).rejects.toThrow('OpenAI API key not configured');
-  });
-
-  it('should throw on callAnthropic without keys', async () => {
-    const openai = new KeyPool({ keys: [] });
-    const anthropic = new KeyPool({ keys: [] });
-    const client = new LLMClient(openai, anthropic);
-
-    await expect(
-      client.complete({
-        provider: 'anthropic',
-        model: 'claude-sonnet-4-20250514',
-        systemPrompt: 'test',
-        userPrompt: 'test',
-        caller: 'test',
-      }),
-    ).rejects.toThrow('Anthropic API key not configured');
-  });
-});