@soleri/core 9.2.0 → 9.3.1

package/src/index.ts

@@ -335,6 +335,14 @@ export {
 } from './planning/gap-types.js';
 export type { GapSeverity, GapCategory, PlanGap } from './planning/gap-types.js';
 
+// ─── Task Complexity Assessor ────────────────────────────────────────
+export { assessTaskComplexity } from './planning/task-complexity-assessor.js';
+export type {
+  AssessmentInput,
+  AssessmentSignal,
+  AssessmentResult,
+} from './planning/task-complexity-assessor.js';
+
 // ─── GitHub Projection ───────────────────────────────────────────────
 export {
   parseGitHubRemote,

package/src/intake/content-classifier.test.ts

@@ -22,7 +22,9 @@ function mockLLM(response: string): LLMClient {
 
 function throwingLLM(error: Error): LLMClient {
   return {
-    complete: async () => { throw error; },
+    complete: async () => {
+      throw error;
+    },
     isAvailable: () => ({ openai: true, anthropic: false }),
     getRoutes: () => [],
   } as unknown as LLMClient;
@@ -34,15 +36,17 @@ function throwingLLM(error: Error): LLMClient {
 
 describe('classifyChunk', () => {
   it('parses valid JSON array response into ClassifiedItems', async () => {
-    const llm = mockLLM(JSON.stringify([
-      {
-        type: 'pattern',
-        title: 'Test Pattern',
-        description: 'A useful design pattern.',
-        tags: ['design', 'architecture'],
-        severity: 'suggestion',
-      },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: 'Test Pattern',
+          description: 'A useful design pattern.',
+          tags: ['design', 'architecture'],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'some text', 'page 1');
 
@@ -56,7 +60,9 @@ describe('classifyChunk', () => {
   });
 
   it('handles markdown fenced JSON responses', async () => {
-    const llm = mockLLM('```json\n[{"type":"pattern","title":"Fenced","description":"Inside fences.","tags":["test"],"severity":"warning"}]\n```');
+    const llm = mockLLM(
+      '```json\n[{"type":"pattern","title":"Fenced","description":"Inside fences.","tags":["test"],"severity":"warning"}]\n```',
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -89,10 +95,24 @@ describe('classifyChunk', () => {
   });
 
   it('filters out items with invalid type', async () => {
-    const llm = mockLLM(JSON.stringify([
-      { type: 'invalid-type', title: 'Bad', description: 'Bad type', tags: [], severity: 'suggestion' },
-      { type: 'pattern', title: 'Good', description: 'Good item.', tags: [], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'invalid-type',
+          title: 'Bad',
+          description: 'Bad type',
+          tags: [],
+          severity: 'suggestion',
+        },
+        {
+          type: 'pattern',
+          title: 'Good',
+          description: 'Good item.',
+          tags: [],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -101,11 +121,19 @@ describe('classifyChunk', () => {
   });
 
   it('filters out items missing required fields (title, description)', async () => {
-    const llm = mockLLM(JSON.stringify([
-      { type: 'pattern', title: '', description: 'No title', tags: [], severity: 'suggestion' },
-      { type: 'pattern', title: 'No desc', description: '', tags: [], severity: 'suggestion' },
-      { type: 'pattern', title: 'Valid', description: 'Valid item.', tags: [], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        { type: 'pattern', title: '', description: 'No title', tags: [], severity: 'suggestion' },
+        { type: 'pattern', title: 'No desc', description: '', tags: [], severity: 'suggestion' },
+        {
+          type: 'pattern',
+          title: 'Valid',
+          description: 'Valid item.',
+          tags: [],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -115,9 +143,17 @@ describe('classifyChunk', () => {
 
   it('truncates title to 80 characters', async () => {
     const longTitle = 'A'.repeat(100);
-    const llm = mockLLM(JSON.stringify([
-      { type: 'pattern', title: longTitle, description: 'Desc.', tags: [], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: longTitle,
+          description: 'Desc.',
+          tags: [],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -126,26 +162,36 @@ describe('classifyChunk', () => {
   });
 
   it('caps tags at 5 and lowercases them', async () => {
-    const llm = mockLLM(JSON.stringify([
-      {
-        type: 'pattern',
-        title: 'Tagged',
-        description: 'Many tags.',
-        tags: ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven'],
-        severity: 'suggestion',
-      },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: 'Tagged',
+          description: 'Many tags.',
+          tags: ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven'],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
     expect(result[0].tags).toHaveLength(5);
-    expect(result[0].tags.every(t => t === t.toLowerCase())).toBe(true);
+    expect(result[0].tags.every((t) => t === t.toLowerCase())).toBe(true);
   });
 
   it('defaults severity to suggestion for invalid values', async () => {
-    const llm = mockLLM(JSON.stringify([
-      { type: 'pattern', title: 'Bad Sev', description: 'Unknown sev.', tags: [], severity: 'unknown' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: 'Bad Sev',
+          description: 'Unknown sev.',
+          tags: [],
+          severity: 'unknown',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -153,24 +199,40 @@ describe('classifyChunk', () => {
   });
 
   it('handles all valid severity values', async () => {
-    const llm = mockLLM(JSON.stringify([
-      { type: 'pattern', title: 'Critical', description: 'Crit.', tags: [], severity: 'critical' },
-      { type: 'pattern', title: 'Warning', description: 'Warn.', tags: [], severity: 'warning' },
-      { type: 'pattern', title: 'Suggestion', description: 'Sug.', tags: [], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: 'Critical',
+          description: 'Crit.',
+          tags: [],
+          severity: 'critical',
+        },
+        { type: 'pattern', title: 'Warning', description: 'Warn.', tags: [], severity: 'warning' },
+        {
+          type: 'pattern',
+          title: 'Suggestion',
+          description: 'Sug.',
+          tags: [],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
-    expect(result.map(r => r.severity)).toEqual(['critical', 'warning', 'suggestion']);
+    expect(result.map((r) => r.severity)).toEqual(['critical', 'warning', 'suggestion']);
   });
 
   it('filters out non-object items in the array', async () => {
-    const llm = mockLLM(JSON.stringify([
-      null,
-      42,
-      'string',
-      { type: 'pattern', title: 'Valid', description: 'OK.', tags: [], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        null,
+        42,
+        'string',
+        { type: 'pattern', title: 'Valid', description: 'OK.', tags: [], severity: 'suggestion' },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 
@@ -179,9 +241,17 @@ describe('classifyChunk', () => {
   });
 
   it('filters non-string tags from the tags array', async () => {
-    const llm = mockLLM(JSON.stringify([
-      { type: 'pattern', title: 'Mixed Tags', description: 'OK.', tags: ['valid', 42, null, 'also-valid'], severity: 'suggestion' },
-    ]));
+    const llm = mockLLM(
+      JSON.stringify([
+        {
+          type: 'pattern',
+          title: 'Mixed Tags',
+          description: 'OK.',
+          tags: ['valid', 42, null, 'also-valid'],
+          severity: 'suggestion',
+        },
+      ]),
+    );
 
     const result = await classifyChunk(llm, 'text', 'cite');
 

package/src/intake/dedup-gate.test.ts

@@ -10,7 +10,7 @@ import type { ClassifiedItem } from './types.js';
 function mockVault(entries: Array<{ id: string; title: string; description: string }> = []): Vault {
   return {
     exportAll: () => ({
-      entries: entries.map(e => ({
+      entries: entries.map((e) => ({
         id: e.id,
         title: e.title,
         description: e.description,
@@ -49,17 +49,19 @@ describe('dedupItems — colocated', () => {
     const results = dedupItems(items, vault);
 
     expect(results).toHaveLength(2);
-    expect(results.every(r => !r.isDuplicate)).toBe(true);
-    expect(results.every(r => r.similarity === 0)).toBe(true);
-    expect(results.every(r => r.bestMatchId === undefined)).toBe(true);
+    expect(results.every((r) => !r.isDuplicate)).toBe(true);
+    expect(results.every((r) => r.similarity === 0)).toBe(true);
+    expect(results.every((r) => r.bestMatchId === undefined)).toBe(true);
   });
 
   it('detects exact duplicate text as duplicate', () => {
-    const vault = mockVault([{
-      id: 'existing-1',
-      title: 'Singleton Pattern',
-      description: 'The singleton pattern ensures a class has only one instance.',
-    }]);
+    const vault = mockVault([
+      {
+        id: 'existing-1',
+        title: 'Singleton Pattern',
+        description: 'The singleton pattern ensures a class has only one instance.',
+      },
+    ]);
 
     const items = [
       makeItem('Singleton Pattern', 'The singleton pattern ensures a class has only one instance.'),
@@ -74,14 +76,19 @@ describe('dedupItems — colocated', () => {
   });
 
   it('does not flag dissimilar items as duplicates', () => {
-    const vault = mockVault([{
-      id: 'existing-2',
-      title: 'Observer Pattern',
-      description: 'Observer defines one-to-many dependency for event-driven communication.',
-    }]);
+    const vault = mockVault([
+      {
+        id: 'existing-2',
+        title: 'Observer Pattern',
+        description: 'Observer defines one-to-many dependency for event-driven communication.',
+      },
+    ]);
 
     const items = [
-      makeItem('Circuit Breaker', 'A resilience pattern that prevents cascading failures in distributed systems.'),
+      makeItem(
+        'Circuit Breaker',
+        'A resilience pattern that prevents cascading failures in distributed systems.',
+      ),
     ];
 
     const results = dedupItems(items, vault);
@@ -103,17 +110,26 @@ describe('dedupItems — colocated', () => {
   });
 
   it('handles multiple items — some duplicate, some not', () => {
-    const vault = mockVault([{
-      id: 'v1',
-      title: 'Factory Method Pattern',
-      description: 'Factory method pattern provides interface for creating objects in a superclass.',
-    }]);
+    const vault = mockVault([
+      {
+        id: 'v1',
+        title: 'Factory Method Pattern',
+        description:
+          'Factory method pattern provides interface for creating objects in a superclass.',
+      },
+    ]);
 
     const items = [
       // Near-duplicate
-      makeItem('Factory Method Pattern', 'Factory method pattern provides interface for creating objects in a superclass.'),
+      makeItem(
+        'Factory Method Pattern',
+        'Factory method pattern provides interface for creating objects in a superclass.',
+      ),
       // Different
-      makeItem('Adapter Pattern', 'Adapter pattern allows incompatible interfaces to work together via a wrapper.'),
+      makeItem(
+        'Adapter Pattern',
+        'Adapter pattern allows incompatible interfaces to work together via a wrapper.',
+      ),
     ];
 
     const results = dedupItems(items, vault);

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

@@ -20,9 +20,11 @@ vi.mock('./content-classifier.js', () => ({
 }));
 
 vi.mock('./dedup-gate.js', () => ({
-  dedupItems: vi.fn().mockImplementation((items: unknown[]) =>
-    items.map((item) => ({ item, isDuplicate: false, similarity: 0 })),
-  ),
+  dedupItems: vi
+    .fn()
+    .mockImplementation((items: unknown[]) =>
+      items.map((item) => ({ item, isDuplicate: false, similarity: 0 })),
+    ),
 }));
 
 vi.mock('node:fs', () => ({

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

@@ -13,13 +13,15 @@ import type { ClassifiedItem } from './types.js';
 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,
-      }))),
+      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,
@@ -29,11 +31,13 @@ function mockLLM(items: ClassifiedItem[]): LLMClient {
   } as unknown as LLMClient;
 }
 
-function mockVault(existingEntries: Array<{ id: string; title: string; description: string }> = []): Vault {
+function mockVault(
+  existingEntries: Array<{ id: string; title: string; description: string }> = [],
+): Vault {
   const seeded: unknown[] = [];
   return {
     exportAll: () => ({
-      entries: existingEntries.map(e => ({
+      entries: existingEntries.map((e) => ({
         id: e.id,
         title: e.title,
         description: e.description,
@@ -43,7 +47,9 @@ function mockVault(existingEntries: Array<{ id: string; title: string; descripti
         tags: [],
       })),
     }),
-    seed: (entries: unknown[]) => { seeded.push(...entries); },
+    seed: (entries: unknown[]) => {
+      seeded.push(...entries);
+    },
     add: vi.fn(),
     _seeded: seeded,
   } as unknown as Vault & { _seeded: unknown[] };
@@ -67,9 +73,7 @@ function makeItem(overrides: Partial<ClassifiedItem> = {}): ClassifiedItem {
 
 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 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);
@@ -126,13 +130,15 @@ describe('TextIngester — ingestText', () => {
       complete: async (): Promise<LLMCallResult> => {
         callCount.n++;
         return {
-          text: JSON.stringify([{
-            type: 'pattern',
-            title: `Item ${callCount.n}`,
-            description: 'A pattern.',
-            tags: ['test'],
-            severity: 'suggestion',
-          }]),
+          text: JSON.stringify([
+            {
+              type: 'pattern',
+              title: `Item ${callCount.n}`,
+              description: 'A pattern.',
+              tags: ['test'],
+              severity: 'suggestion',
+            },
+          ]),
           model: 'mock',
           provider: 'openai' as const,
           durationMs: 0,

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

@@ -222,9 +222,7 @@ describe('loadKeyPoolConfig', () => {
 
   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'] }),
-    );
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ openai: ['sk-file'] }));
     process.env.ANTHROPIC_API_KEY = 'sk-env-ant';
 
     const config = loadKeyPoolConfig('test-agent');

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

@@ -7,10 +7,7 @@ import { LLMError } from './types.js';
 // HELPERS
 // =============================================================================
 
-function makeClient(opts?: {
-  openaiKeys?: string[];
-  anthropicKeys?: string[];
-}): LLMClient {
+function makeClient(opts?: { openaiKeys?: string[]; anthropicKeys?: string[] }): LLMClient {
   const openai = new KeyPool({ keys: opts?.openaiKeys ?? [] });
   const anthropic = new KeyPool({ keys: opts?.anthropicKeys ?? [] });
   return new LLMClient(openai, anthropic);

package/src/llm/oauth-discovery.test.ts

@@ -37,7 +37,9 @@ describe('discoverAnthropicToken', () => {
     delete process.env.ANTHROPIC_API_KEY;
     vi.mocked(existsSync).mockReturnValue(false);
     vi.mocked(readFileSync).mockReturnValue('{}');
-    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('not found'); });
+    vi.mocked(execFileSync).mockImplementation(() => {
+      throw new Error('not found');
+    });
     vi.mocked(platform).mockReturnValue('darwin');
   });
 
@@ -69,18 +71,14 @@ describe('discoverAnthropicToken', () => {
 
   it('should return token from credentials file with direct accessToken', async () => {
     vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockReturnValue(
-      JSON.stringify({ accessToken: 'direct-token' }),
-    );
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ accessToken: 'direct-token' }));
     const discover = await freshDiscover();
     expect(discover()).toBe('direct-token');
   });
 
   it('should return token from credentials file with apiKey field', async () => {
     vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockReturnValue(
-      JSON.stringify({ apiKey: 'api-key-field' }),
-    );
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ apiKey: 'api-key-field' }));
     const discover = await freshDiscover();
     expect(discover()).toBe('api-key-field');
   });
@@ -101,9 +99,7 @@ describe('discoverAnthropicToken', () => {
 
   it('should handle keychain returning non-JSON with regex fallback', async () => {
     vi.mocked(platform).mockReturnValue('darwin');
-    vi.mocked(execFileSync).mockReturnValue(
-      '{ truncated "accessToken": "regex-token" garbage',
-    );
+    vi.mocked(execFileSync).mockReturnValue('{ truncated "accessToken": "regex-token" garbage');
     const discover = await freshDiscover();
     expect(discover()).toBe('regex-token');
   });
@@ -124,7 +120,9 @@ describe('discoverAnthropicToken', () => {
 
   it('should treat long raw string from Linux keyring as token', async () => {
     vi.mocked(platform).mockReturnValue('linux');
-    vi.mocked(execFileSync).mockReturnValue('a-long-raw-token-string-that-is-definitely-over-twenty-chars');
+    vi.mocked(execFileSync).mockReturnValue(
+      'a-long-raw-token-string-that-is-definitely-over-twenty-chars',
+    );
     const discover = await freshDiscover();
     expect(discover()).toBe('a-long-raw-token-string-that-is-definitely-over-twenty-chars');
   });
@@ -142,14 +140,18 @@ describe('discoverAnthropicToken', () => {
 
   it('should handle credentials file read errors gracefully', async () => {
     vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockImplementation(() => { throw new Error('permission denied'); });
+    vi.mocked(readFileSync).mockImplementation(() => {
+      throw new Error('permission denied');
+    });
     const discover = await freshDiscover();
     expect(discover()).toBeNull();
   });
 
   it('should handle keychain errors gracefully', async () => {
     vi.mocked(platform).mockReturnValue('darwin');
-    vi.mocked(execFileSync).mockImplementation(() => { throw new Error('no keychain entry'); });
+    vi.mocked(execFileSync).mockImplementation(() => {
+      throw new Error('no keychain entry');
+    });
     const discover = await freshDiscover();
     expect(discover()).toBeNull();
   });
@@ -164,9 +166,7 @@ describe('discoverAnthropicToken', () => {
   it('should prioritize env var over credentials file', async () => {
     process.env.ANTHROPIC_API_KEY = 'env-key';
     vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockReturnValue(
-      JSON.stringify({ apiKey: 'file-key' }),
-    );
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ apiKey: 'file-key' }));
     const discover = await freshDiscover();
     expect(discover()).toBe('env-key');
   });