@soleri/core 2.10.0 → 2.11.0

package/src/__tests__/replayable-stream.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { ReplayableStream } from '../streams/replayable-stream.js';
+import { ReplayableStream, fanOut } from '../streams/replayable-stream.js';
 
 async function* generate(items: number[]): AsyncIterable<number> {
   for (const item of items) yield item;
@@ -63,4 +63,115 @@ describe('ReplayableStream', () => {
     for await (const item of stream) items.push(item);
     expect(items).toEqual([5, 6]);
   });
+
+  it('works with slow async source', async () => {
+    async function* slow(): AsyncIterable<number> {
+      for (let i = 1; i <= 3; i++) {
+        await new Promise((r) => setTimeout(r, 10));
+        yield i;
+      }
+    }
+    const stream = new ReplayableStream(slow());
+    expect(await stream.collect()).toEqual([1, 2, 3]);
+  });
+
+  it('concurrent consumers on slow source all see identical results', async () => {
+    async function* slow(): AsyncIterable<number> {
+      for (let i = 1; i <= 5; i++) {
+        await new Promise((r) => setTimeout(r, 5));
+        yield i;
+      }
+    }
+    const stream = new ReplayableStream(slow());
+    const [a, b, c] = await Promise.all([stream.collect(), stream.collect(), stream.collect()]);
+    expect(a).toEqual([1, 2, 3, 4, 5]);
+    expect(b).toEqual([1, 2, 3, 4, 5]);
+    expect(c).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('late consumer replays full stream after completion', async () => {
+    const stream = new ReplayableStream(generate([10, 20, 30]));
+    // Drain the stream first
+    await stream.collect();
+    expect(stream.isDone).toBe(true);
+    // Late consumer should still see everything
+    expect(await stream.collect()).toEqual([10, 20, 30]);
+  });
+
+  it('maxBuffer evicts oldest entries', async () => {
+    const stream = new ReplayableStream(generate([1, 2, 3, 4, 5]), {
+      maxBuffer: 3,
+    });
+    await stream.collect();
+    // Buffer should only hold the last 3 items
+    expect(stream.bufferedCount).toBe(3);
+  });
+
+  it('late consumer throws when evicted items are needed', async () => {
+    async function* slow(): AsyncIterable<number> {
+      for (let i = 1; i <= 5; i++) {
+        await new Promise((r) => setTimeout(r, 2));
+        yield i;
+      }
+    }
+    const stream = new ReplayableStream(slow(), { maxBuffer: 2 });
+    // Drain the stream fully — evicts items 1, 2, 3
+    await stream.collect();
+    // Late consumer starts at index 0 but items 0-2 are evicted
+    await expect(stream.collect()).rejects.toThrow('consumer fell behind');
+  });
+});
+
+describe('fanOut', () => {
+  it('feeds one source to multiple consumers in parallel', async () => {
+    async function* source(): AsyncIterable<string> {
+      yield 'plan-result';
+      yield 'session-data';
+      yield 'extraction';
+    }
+
+    const brainLog: string[] = [];
+    const vaultLog: string[] = [];
+    const cogneeLog: string[] = [];
+
+    await fanOut(source(), [
+      async (items) => {
+        for await (const item of items) brainLog.push(`brain:${item}`);
+      },
+      async (items) => {
+        for await (const item of items) vaultLog.push(`vault:${item}`);
+      },
+      async (items) => {
+        for await (const item of items) cogneeLog.push(`cognee:${item}`);
+      },
+    ]);
+
+    const expected = ['plan-result', 'session-data', 'extraction'];
+    expect(brainLog).toEqual(expected.map((e) => `brain:${e}`));
+    expect(vaultLog).toEqual(expected.map((e) => `vault:${e}`));
+    expect(cogneeLog).toEqual(expected.map((e) => `cognee:${e}`));
+  });
+
+  it('source executes only once with fanOut', async () => {
+    let callCount = 0;
+    async function* tracked(): AsyncIterable<number> {
+      callCount++;
+      yield 1;
+      yield 2;
+    }
+
+    const results: number[][] = [[], []];
+    await fanOut(tracked(), [
+      async (items) => {
+        for await (const item of items) results[0].push(item);
+      },
+      async (items) => {
+        for await (const item of items) results[1].push(item);
+      },
+    ]);
+
+    expect(callCount).toBe(1);
+    expect(results[0]).toEqual([1, 2]);
+    expect(results[1]).toEqual([1, 2]);
+  });
 });

package/src/__tests__/scope-detector.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { detectScope } from '../vault/scope-detector.js';
+import type { ScopeInput } from '../vault/scope-detector.js';
+
+describe('detectScope', () => {
+  it('classifies project-specific paths as project tier with HIGH confidence', () => {
+    const input: ScopeInput = {
+      title: 'Monorepo package structure',
+      description: 'In packages/core/src/vault.ts, we use SQLite for persistence.',
+      tags: ['project-specific'],
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('project');
+    expect(result.confidence).toBe('HIGH');
+  });
+
+  it('classifies universal TypeScript patterns as team tier', () => {
+    const input: ScopeInput = {
+      title: 'Type safety best practice',
+      description: 'Always use type guards instead of type assertions for runtime safety.',
+      tags: ['typescript', 'best-practice'],
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('team');
+  });
+
+  it('classifies personal preferences as agent tier', () => {
+    const input: ScopeInput = {
+      title: 'My editor setup',
+      description: 'I prefer using vim keybindings in my IDE. My workflow involves ~/projects.',
+      tags: ['preference'],
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('agent');
+  });
+
+  it('classifies accessibility concepts as team tier', () => {
+    const input: ScopeInput = {
+      title: 'WCAG contrast requirements',
+      description: 'All text must meet WCAG AA contrast ratio of 4.5:1 for accessibility.',
+      category: 'accessibility',
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('team');
+    expect(result.confidence).toBe('HIGH');
+  });
+
+  it('returns LOW confidence for mixed signals', () => {
+    const input: ScopeInput = {
+      title: 'Clean code in our codebase',
+      description: 'Our project follows clean code principles. In packages/core we enforce SOLID.',
+      tags: ['best-practice', 'project-specific'],
+    };
+    const result = detectScope(input);
+    // Should have LOW or MEDIUM confidence due to conflicting signals
+    expect(['LOW', 'MEDIUM']).toContain(result.confidence);
+  });
+
+  it('defaults to agent tier with LOW confidence when no signals', () => {
+    const input: ScopeInput = {
+      title: 'Random note',
+      description: 'Something happened today.',
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('agent');
+    expect(result.confidence).toBe('LOW');
+    expect(result.reason).toContain('No clear signals');
+  });
+
+  it('detects scoped packages as project-specific', () => {
+    const input: ScopeInput = {
+      title: 'Package usage',
+      description: 'Use @soleri/core for all vault operations, not direct SQLite.',
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('project');
+  });
+
+  it('detects security patterns as team tier', () => {
+    const input: ScopeInput = {
+      title: 'XSS prevention',
+      description: 'Sanitize all user input to prevent XSS injection attacks.',
+      category: 'security',
+      tags: ['security'],
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('team');
+    expect(result.confidence).toBe('HIGH');
+  });
+
+  it('includes signals in result', () => {
+    const input: ScopeInput = {
+      title: 'Focus ring pattern',
+      description:
+        'All interactive elements must have a visible focus ring for keyboard navigation.',
+    };
+    const result = detectScope(input);
+    expect(result.signals.length).toBeGreaterThan(0);
+    expect(result.signals.some((s) => s.source === 'content')).toBe(true);
+  });
+
+  it('category signal boosts classification', () => {
+    const input: ScopeInput = {
+      title: 'Color palette choice',
+      description: 'Use harmonious color palettes for UI consistency.',
+      category: 'design',
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('team');
+  });
+
+  it('agent tags classify as agent', () => {
+    const input: ScopeInput = {
+      title: 'Terminal config',
+      description: 'Set up zsh with custom prompt.',
+      tags: ['personal', 'workflow'],
+    };
+    const result = detectScope(input);
+    expect(result.tier).toBe('agent');
+  });
+});

package/src/__tests__/session-lifecycle.test.ts

@@ -0,0 +1,259 @@
+/**
+ * Session Lifecycle Tests — list, get, quality scoring, replay.
+ *
+ * Covers the #178 additions to BrainIntelligence: public session query,
+ * 4-dimension quality scoring, and session replay.
+ */
+
+import { describe, test, expect, beforeEach } from 'vitest';
+import { Vault } from '../vault/vault.js';
+import { Brain } from '../brain/brain.js';
+import { BrainIntelligence } from '../brain/intelligence.js';
+
+describe('Session Lifecycle', () => {
+  let vault: Vault;
+  let brain: Brain;
+  let intelligence: BrainIntelligence;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    brain = new Brain(vault);
+    intelligence = new BrainIntelligence(vault, brain);
+  });
+
+  // ─── getSessionById ─────────────────────────────────────────────
+
+  test('getSessionById returns null for non-existent session', () => {
+    expect(intelligence.getSessionById('non-existent')).toBeNull();
+  });
+
+  test('getSessionById returns session after lifecycle start', () => {
+    const session = intelligence.lifecycle({ action: 'start', domain: 'design' });
+    const found = intelligence.getSessionById(session.id);
+    expect(found).not.toBeNull();
+    expect(found!.id).toBe(session.id);
+    expect(found!.domain).toBe('design');
+  });
+
+  // ─── listSessions ──────────────────────────────────────────────
+
+  test('listSessions returns all sessions', () => {
+    intelligence.lifecycle({ action: 'start', domain: 'design' });
+    intelligence.lifecycle({ action: 'start', domain: 'a11y' });
+    intelligence.lifecycle({ action: 'start', domain: 'performance' });
+
+    const sessions = intelligence.listSessions();
+    expect(sessions.length).toBe(3);
+  });
+
+  test('listSessions filters by domain', () => {
+    intelligence.lifecycle({ action: 'start', domain: 'design' });
+    intelligence.lifecycle({ action: 'start', domain: 'a11y' });
+    intelligence.lifecycle({ action: 'start', domain: 'design' });
+
+    const sessions = intelligence.listSessions({ domain: 'design' });
+    expect(sessions.length).toBe(2);
+    expect(sessions.every((s) => s.domain === 'design')).toBe(true);
+  });
+
+  test('listSessions filters active sessions', () => {
+    const s1 = intelligence.lifecycle({ action: 'start', domain: 'design' });
+    intelligence.lifecycle({ action: 'start', domain: 'a11y' });
+    intelligence.lifecycle({ action: 'end', sessionId: s1.id });
+
+    const active = intelligence.listSessions({ active: true });
+    expect(active.length).toBe(1);
+    expect(active[0].domain).toBe('a11y');
+
+    const completed = intelligence.listSessions({ active: false });
+    expect(completed.length).toBe(1);
+    expect(completed[0].id).toBe(s1.id);
+  });
+
+  test('listSessions filters extracted sessions', () => {
+    const s1 = intelligence.lifecycle({
+      action: 'start',
+      domain: 'design',
+      toolsUsed: ['tool1', 'tool1', 'tool1'],
+    });
+    intelligence.lifecycle({ action: 'start', domain: 'a11y' });
+    // End s1 — triggers auto-extract since it has tool usage
+    intelligence.lifecycle({ action: 'end', sessionId: s1.id });
+
+    const extracted = intelligence.listSessions({ extracted: true });
+    expect(extracted.length).toBe(1);
+    expect(extracted[0].id).toBe(s1.id);
+
+    const notExtracted = intelligence.listSessions({ extracted: false });
+    expect(notExtracted.length).toBe(1);
+    expect(notExtracted[0].domain).toBe('a11y');
+  });
+
+  test('listSessions respects limit and offset', () => {
+    for (let i = 0; i < 10; i++) {
+      intelligence.lifecycle({ action: 'start', domain: `d${i}` });
+    }
+
+    const page1 = intelligence.listSessions({ limit: 3, offset: 0 });
+    expect(page1.length).toBe(3);
+
+    const page2 = intelligence.listSessions({ limit: 3, offset: 3 });
+    expect(page2.length).toBe(3);
+
+    // No overlap
+    const ids1 = new Set(page1.map((s) => s.id));
+    const ids2 = new Set(page2.map((s) => s.id));
+    expect([...ids1].some((id) => ids2.has(id))).toBe(false);
+  });
+
+  // ─── computeSessionQuality ─────────────────────────────────────
+
+  test('computeSessionQuality throws for non-existent session', () => {
+    expect(() => intelligence.computeSessionQuality('nope')).toThrow('Session not found');
+  });
+
+  test('minimal session scores low', () => {
+    const session = intelligence.lifecycle({ action: 'start' });
+    const quality = intelligence.computeSessionQuality(session.id);
+
+    expect(quality.sessionId).toBe(session.id);
+    expect(quality.overall).toBe(0);
+    expect(quality.completeness).toBe(0);
+    expect(quality.artifactDensity).toBe(0);
+    expect(quality.toolEngagement).toBe(0);
+    expect(quality.outcomeClarity).toBe(0);
+  });
+
+  test('completed session with context and domain scores higher', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      domain: 'design',
+      context: 'Building a card component',
+    });
+    intelligence.lifecycle({ action: 'end', sessionId: session.id });
+
+    const quality = intelligence.computeSessionQuality(session.id);
+    // ended (10) + context (8) + domain (7) = 25
+    expect(quality.completeness).toBe(25);
+    expect(quality.overall).toBeGreaterThan(0);
+  });
+
+  test('files modified boost artifact density', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      filesModified: ['a.ts', 'b.ts', 'c.ts'],
+    });
+    const quality = intelligence.computeSessionQuality(session.id);
+    // 3 files * 5 = 15
+    expect(quality.artifactDensity).toBe(15);
+  });
+
+  test('artifact density caps at 25', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      filesModified: Array.from({ length: 20 }, (_, i) => `file-${i}.ts`),
+    });
+    const quality = intelligence.computeSessionQuality(session.id);
+    expect(quality.artifactDensity).toBe(25);
+  });
+
+  test('unique tools boost tool engagement', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      toolsUsed: ['search', 'create', 'validate', 'search', 'search'],
+    });
+    const quality = intelligence.computeSessionQuality(session.id);
+    // 3 unique tools * 5 = 15
+    expect(quality.toolEngagement).toBe(15);
+  });
+
+  test('plan outcome boosts outcome clarity', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      planId: 'plan-123',
+    });
+    intelligence.lifecycle({
+      action: 'end',
+      sessionId: session.id,
+      planOutcome: 'completed',
+    });
+
+    const quality = intelligence.computeSessionQuality(session.id);
+    // planId (8) + completed (10) + extractedAt (7, auto-extract fires because planId+planOutcome)
+    expect(quality.outcomeClarity).toBe(25);
+  });
+
+  test('overall is sum of all dimensions, max 100', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      domain: 'design',
+      context: 'Full session',
+      toolsUsed: ['t1', 't2', 't3', 't4', 't5'],
+      filesModified: ['f1', 'f2', 'f3', 'f4', 'f5'],
+      planId: 'plan-1',
+    });
+    intelligence.lifecycle({
+      action: 'end',
+      sessionId: session.id,
+      planOutcome: 'completed',
+    });
+
+    const quality = intelligence.computeSessionQuality(session.id);
+    expect(quality.overall).toBe(
+      quality.completeness +
+        quality.artifactDensity +
+        quality.toolEngagement +
+        quality.outcomeClarity,
+    );
+    expect(quality.overall).toBeLessThanOrEqual(100);
+  });
+
+  // ─── replaySession ─────────────────────────────────────────────
+
+  test('replaySession throws for non-existent session', () => {
+    expect(() => intelligence.replaySession('nope')).toThrow('Session not found');
+  });
+
+  test('replaySession returns complete session data', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      domain: 'design',
+      context: 'Test replay',
+      toolsUsed: ['search', 'search', 'search', 'create'],
+      filesModified: ['a.ts', 'b.ts', 'c.ts'],
+      planId: 'plan-replay',
+    });
+    intelligence.lifecycle({
+      action: 'end',
+      sessionId: session.id,
+      planOutcome: 'completed',
+    });
+
+    const replay = intelligence.replaySession(session.id);
+
+    expect(replay.session.id).toBe(session.id);
+    expect(replay.session.domain).toBe('design');
+    expect(replay.quality.overall).toBeGreaterThan(0);
+    expect(replay.durationMinutes).not.toBeNull();
+    // Auto-extract should have generated proposals
+    expect(replay.proposals.length).toBeGreaterThan(0);
+  });
+
+  test('replaySession returns null duration for active session', () => {
+    const session = intelligence.lifecycle({ action: 'start' });
+    const replay = intelligence.replaySession(session.id);
+    expect(replay.durationMinutes).toBeNull();
+  });
+
+  test('replaySession includes quality scores', () => {
+    const session = intelligence.lifecycle({
+      action: 'start',
+      domain: 'perf',
+      context: 'Optimizing queries',
+    });
+
+    const replay = intelligence.replaySession(session.id);
+    expect(replay.quality.sessionId).toBe(session.id);
+    expect(replay.quality.completeness).toBeGreaterThan(0);
+  });
+});