@soleri/core 9.0.3 → 9.2.0

package/src/intake/text-ingester.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TextIngester } from './text-ingester.js';
+import type { IngestSource, IngestOptions } from './text-ingester.js';
+import type { Vault } from '../vault/vault.js';
+import type { LLMClient } from '../llm/llm-client.js';
+import type { LLMCallResult } from '../llm/types.js';
+import type { ClassifiedItem } from './types.js';
+
+// =============================================================================
+// MOCKS
+// =============================================================================
+
+function mockLLM(items: ClassifiedItem[]): LLMClient {
+  return {
+    complete: async (): Promise<LLMCallResult> => ({
+      text: JSON.stringify(items.map(i => ({
+        type: i.type,
+        title: i.title,
+        description: i.description,
+        tags: i.tags,
+        severity: i.severity,
+      }))),
+      model: 'mock',
+      provider: 'openai' as const,
+      durationMs: 0,
+    }),
+    isAvailable: () => ({ openai: true, anthropic: false }),
+    getRoutes: () => [],
+  } as unknown as LLMClient;
+}
+
+function mockVault(existingEntries: Array<{ id: string; title: string; description: string }> = []): Vault {
+  const seeded: unknown[] = [];
+  return {
+    exportAll: () => ({
+      entries: existingEntries.map(e => ({
+        id: e.id,
+        title: e.title,
+        description: e.description,
+        type: 'pattern',
+        domain: 'test',
+        severity: 'suggestion',
+        tags: [],
+      })),
+    }),
+    seed: (entries: unknown[]) => { seeded.push(...entries); },
+    add: vi.fn(),
+    _seeded: seeded,
+  } as unknown as Vault & { _seeded: unknown[] };
+}
+
+function makeItem(overrides: Partial<ClassifiedItem> = {}): ClassifiedItem {
+  return {
+    type: 'pattern',
+    title: overrides.title ?? 'Test Pattern',
+    description: overrides.description ?? 'A test pattern description.',
+    tags: overrides.tags ?? ['test'],
+    severity: overrides.severity ?? 'suggestion',
+    citation: overrides.citation ?? 'test',
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+describe('TextIngester — ingestText', () => {
+  it('classifies, deduplicates, and stores unique items in vault', async () => {
+    const items = [
+      makeItem({ title: 'Pattern A', description: 'Unique pattern about testing.' }),
+    ];
+    const llm = mockLLM(items);
+    const vault = mockVault() as Vault & { _seeded: unknown[] };
+    const ingester = new TextIngester(vault, llm);
+
+    const source: IngestSource = { type: 'notes', title: 'My Notes' };
+    const result = await ingester.ingestText('Some long text about patterns.', source);
+
+    expect(result.source).toEqual(source);
+    expect(result.ingested).toBe(1);
+    expect(result.duplicates).toBe(0);
+    expect(result.entries).toHaveLength(1);
+    expect(result.entries[0].title).toBe('Pattern A');
+    expect(vault._seeded.length).toBeGreaterThan(0);
+  });
+
+  it('returns empty result when LLM is null', async () => {
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, null);
+
+    const result = await ingester.ingestText('text', { type: 'notes', title: 'Test' });
+
+    expect(result.ingested).toBe(0);
+    expect(result.duplicates).toBe(0);
+    expect(result.entries).toEqual([]);
+  });
+
+  it('returns empty result when classifier extracts no items', async () => {
+    const llm = mockLLM([]);
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, llm);
+
+    const result = await ingester.ingestText('nothing useful', { type: 'notes', title: 'Test' });
+
+    expect(result.ingested).toBe(0);
+  });
+
+  it('applies domain and tags from options', async () => {
+    const items = [makeItem()];
+    const llm = mockLLM(items);
+    const vault = mockVault() as Vault & { _seeded: unknown[] };
+    const ingester = new TextIngester(vault, llm);
+
+    const opts: IngestOptions = { domain: 'security', tags: ['custom-tag'] };
+    const result = await ingester.ingestText('text', { type: 'documentation', title: 'Doc' }, opts);
+
+    expect(result.ingested).toBe(1);
+    // Seeded entries should exist
+    expect(vault._seeded.length).toBeGreaterThan(0);
+  });
+
+  it('splits long text into chunks based on chunkSize option', async () => {
+    const callCount = { n: 0 };
+    const llm = {
+      complete: async (): Promise<LLMCallResult> => {
+        callCount.n++;
+        return {
+          text: JSON.stringify([{
+            type: 'pattern',
+            title: `Item ${callCount.n}`,
+            description: 'A pattern.',
+            tags: ['test'],
+            severity: 'suggestion',
+          }]),
+          model: 'mock',
+          provider: 'openai' as const,
+          durationMs: 0,
+        };
+      },
+      isAvailable: () => ({ openai: true, anthropic: false }),
+      getRoutes: () => [],
+    } as unknown as LLMClient;
+
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, llm);
+
+    // Text longer than chunk size should be split
+    const longText = 'A'.repeat(100);
+    await ingester.ingestText(longText, { type: 'notes', title: 'Test' }, { chunkSize: 30 });
+
+    expect(callCount.n).toBeGreaterThan(1);
+  });
+});
+
+describe('TextIngester — ingestUrl', () => {
+  it('returns empty result when LLM is null', async () => {
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, null);
+
+    const result = await ingester.ingestUrl('https://example.com');
+
+    expect(result.ingested).toBe(0);
+    expect(result.source.type).toBe('article');
+  });
+});
+
+describe('TextIngester — ingestBatch', () => {
+  it('processes multiple items sequentially', async () => {
+    const items = [makeItem({ title: 'Batch Item' })];
+    const llm = mockLLM(items);
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, llm);
+
+    const results = await ingester.ingestBatch([
+      { text: 'First item text.', source: { type: 'notes', title: 'Note 1' } },
+      { text: 'Second item text.', source: { type: 'transcript', title: 'Talk 1' } },
+    ]);
+
+    expect(results).toHaveLength(2);
+    expect(results[0].source.title).toBe('Note 1');
+    expect(results[1].source.title).toBe('Talk 1');
+  });
+
+  it('returns empty array for empty batch', async () => {
+    const llm = mockLLM([]);
+    const vault = mockVault();
+    const ingester = new TextIngester(vault, llm);
+
+    const results = await ingester.ingestBatch([]);
+
+    expect(results).toEqual([]);
+  });
+});

package/src/intake/text-ingester.ts

@@ -104,6 +104,7 @@ export class TextIngester {
     // Classify all chunks
     const allItems: ClassifiedItem[] = [];
     for (const chunk of chunks) {
+      // oxlint-disable-next-line eslint(no-await-in-loop)
       const items = await classifyChunk(this.llm, chunk, `${source.type}: ${source.title}`);
       allItems.push(...items);
     }
@@ -153,6 +154,7 @@ export class TextIngester {
   ): Promise<IngestResult[]> {
     const results: IngestResult[] = [];
     for (const item of items) {
+      // oxlint-disable-next-line eslint(no-await-in-loop)
       const result = await this.ingestText(item.text, item.source, item.opts);
       results.push(result);
     }

package/src/llm/key-pool.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { KeyPool, loadKeyPoolConfig } from './key-pool.js';
+
+// ─── Mocks ──────────────────────────────────────────────────────────
+
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+vi.mock('../paths.js', () => ({
+  agentKeysPath: vi.fn((agentId: string) => `/mock/.soleri/${agentId}/keys.json`),
+}));
+
+import * as fs from 'node:fs';
+
+// ─── KeyPool ────────────────────────────────────────────────────────
+
+describe('KeyPool', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('should initialize with valid keys', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'] });
+    expect(pool.hasKeys).toBe(true);
+    expect(pool.poolSize).toBe(2);
+    expect(pool.activeKeyIndex).toBe(0);
+  });
+
+  it('should filter out empty keys', () => {
+    const pool = new KeyPool({ keys: ['', 'key-a', ''] });
+    expect(pool.poolSize).toBe(1);
+  });
+
+  it('should report no keys when all are empty', () => {
+    const pool = new KeyPool({ keys: ['', ''] });
+    expect(pool.hasKeys).toBe(false);
+    expect(pool.poolSize).toBe(0);
+  });
+
+  it('should return the active key', () => {
+    const pool = new KeyPool({ keys: ['key-a'] });
+    expect(pool.getActiveKey().expose()).toBe('key-a');
+  });
+
+  it('should throw when getting key from empty pool', () => {
+    const pool = new KeyPool({ keys: [] });
+    expect(() => pool.getActiveKey()).toThrow('no keys');
+  });
+
+  it('should report exhausted for empty pool', () => {
+    const pool = new KeyPool({ keys: [] });
+    expect(pool.exhausted).toBe(true);
+  });
+
+  it('should not be exhausted when healthy keys exist', () => {
+    const pool = new KeyPool({ keys: ['key-a'] });
+    expect(pool.exhausted).toBe(false);
+  });
+
+  it('should rotate to next key on error', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b', 'key-c'] });
+    expect(pool.activeKeyIndex).toBe(0);
+
+    const next = pool.rotateOnError();
+    expect(next).not.toBeNull();
+    expect(next!.expose()).toBe('key-b');
+    expect(pool.activeKeyIndex).toBe(1);
+  });
+
+  it('should skip unhealthy keys during rotation', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b', 'key-c'], preemptiveThreshold: 10 });
+
+    // Trip breaker on key-b (index 1): rotate from 0 → records failure on 0, finds 1
+    pool.rotateOnError(); // now on key-b (1)
+    // Trip breaker on key-b by calling rotateOnError 3 times from index 1
+    pool.rotateOnError(); // failure on 1, rotate to 2
+    pool.rotateOnError(); // failure on 2, rotate to 0
+    pool.rotateOnError(); // failure on 0, rotate to 1
+
+    // Each key has had 1-2 failures, none tripped (threshold=3)
+    expect(pool.exhausted).toBe(false);
+  });
+
+  it('should return null when all keys are exhausted', () => {
+    const pool = new KeyPool({ keys: ['key-a'] });
+
+    // Trip the single key's circuit breaker (default threshold=3)
+    pool.rotateOnError();
+    pool.rotateOnError();
+    pool.rotateOnError();
+
+    pool.rotateOnError();
+    // After enough failures the breaker opens
+    expect(pool.exhausted).toBe(true);
+  });
+
+  it('should perform preemptive rotation when quota is low', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'], preemptiveThreshold: 100 });
+    pool.updateQuota(0, 10);
+
+    const rotated = pool.rotatePreemptive();
+    expect(rotated).toBe(true);
+    expect(pool.activeKeyIndex).toBe(1);
+  });
+
+  it('should not preemptively rotate when quota is above threshold', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'], preemptiveThreshold: 100 });
+    pool.updateQuota(0, 200);
+
+    const rotated = pool.rotatePreemptive();
+    expect(rotated).toBe(false);
+    expect(pool.activeKeyIndex).toBe(0);
+  });
+
+  it('should not preemptively rotate when no quota info exists', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'], preemptiveThreshold: 100 });
+    const rotated = pool.rotatePreemptive();
+    expect(rotated).toBe(false);
+  });
+
+  it('should use default preemptive threshold of 50', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'] });
+    pool.updateQuota(0, 49);
+    expect(pool.rotatePreemptive()).toBe(true);
+  });
+
+  it('should return full status', () => {
+    const pool = new KeyPool({ keys: ['key-a', 'key-b'] });
+    pool.updateQuota(0, 100);
+    const status = pool.getStatus();
+
+    expect(status.poolSize).toBe(2);
+    expect(status.activeKeyIndex).toBe(0);
+    expect(status.exhausted).toBe(false);
+    expect(status.perKeyStatus).toHaveLength(2);
+    expect(status.perKeyStatus[0].remainingQuota).toBe(100);
+    expect(status.perKeyStatus[1].remainingQuota).toBeNull();
+  });
+});
+
+// ─── loadKeyPoolConfig ──────────────────────────────────────────────
+
+describe('loadKeyPoolConfig', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    process.env = { ...originalEnv };
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  it('should reject invalid agentId with slashes', () => {
+    expect(() => loadKeyPoolConfig('../evil')).toThrow('Invalid agentId');
+  });
+
+  it('should reject empty agentId', () => {
+    expect(() => loadKeyPoolConfig('')).toThrow('Invalid agentId');
+  });
+
+  it('should reject agentId with backslashes', () => {
+    expect(() => loadKeyPoolConfig('foo\\bar')).toThrow('Invalid agentId');
+  });
+
+  it('should load keys from keys.json file', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ openai: ['sk-openai-1'], anthropic: ['sk-ant-1'] }),
+    );
+
+    const config = loadKeyPoolConfig('test-agent');
+    expect(config.openai.keys).toEqual(['sk-openai-1']);
+    expect(config.anthropic.keys).toEqual(['sk-ant-1']);
+  });
+
+  it('should fall back to env vars when keys.json does not exist', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    process.env.OPENAI_API_KEY = 'sk-env-openai';
+    process.env.ANTHROPIC_API_KEY = 'sk-env-anthropic';
+
+    const config = loadKeyPoolConfig('test-agent');
+    expect(config.openai.keys).toEqual(['sk-env-openai']);
+    expect(config.anthropic.keys).toEqual(['sk-env-anthropic']);
+  });
+
+  it('should return empty arrays when no keys available', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const config = loadKeyPoolConfig('test-agent');
+    expect(config.openai.keys).toEqual([]);
+    expect(config.anthropic.keys).toEqual([]);
+  });
+
+  it('should handle malformed keys.json gracefully', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue('not json');
+
+    const config = loadKeyPoolConfig('test-agent');
+    // Falls back to env vars (none set), so empty
+    expect(config.openai.keys).toEqual([]);
+    expect(config.anthropic.keys).toEqual([]);
+  });
+
+  it('should handle keys.json with non-array values', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ openai: 'not-an-array', anthropic: 42 }),
+    );
+
+    const config = loadKeyPoolConfig('test-agent');
+    expect(config.openai.keys).toEqual([]);
+    expect(config.anthropic.keys).toEqual([]);
+  });
+
+  it('should use env vars for providers missing from keys.json', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ openai: ['sk-file'] }),
+    );
+    process.env.ANTHROPIC_API_KEY = 'sk-env-ant';
+
+    const config = loadKeyPoolConfig('test-agent');
+    expect(config.openai.keys).toEqual(['sk-file']);
+    expect(config.anthropic.keys).toEqual(['sk-env-ant']);
+  });
+});
+
+import { afterAll } from 'vitest';

package/src/llm/key-pool.ts

@@ -1,9 +1,8 @@
 import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { homedir } from 'node:os';
 import { SecretString } from './types.js';
 import type { KeyPoolConfig, KeyStatus } from './types.js';
 import { CircuitBreaker } from './utils.js';
+import { agentKeysPath } from '../paths.js';
 
 // =============================================================================
 // CONSTANTS
@@ -146,7 +145,7 @@ export interface KeyPoolFiles {
 /**
  * Load key pool configuration for an agent.
  * Key loading priority:
- * 1. ~/.{agentId}/keys.json
+ * 1. ~/.soleri/{agentId}/keys.json
  * 2. Fallback: OPENAI_API_KEY / ANTHROPIC_API_KEY env vars
  * 3. Empty pool
  */
@@ -154,7 +153,7 @@ export function loadKeyPoolConfig(agentId: string): KeyPoolFiles {
   if (!agentId || /[/\\]/.test(agentId) || agentId.includes('..')) {
     throw new Error(`Invalid agentId: ${agentId}`);
   }
-  const keysFilePath = path.join(homedir(), `.${agentId}`, 'keys.json');
+  const keysFilePath = agentKeysPath(agentId);
 
   let openaiKeys: string[] = [];
   let anthropicKeys: string[] = [];