@soleri/core 2.12.0 → 8.0.0

package/src/__tests__/core-ops.test.ts

@@ -34,8 +34,9 @@ describe('createSemanticFacades', () => {
     return op;
   }
 
-  it('should return 232 ops', () => {
-    expect(ops.length).toBe(314);
+  it('should return ops from all semantic facades (without cognee)', () => {
+    // Op count varies as new ops are added. Just verify a reasonable minimum.
+    expect(ops.length).toBeGreaterThan(250);
   });
 
   it('should have all expected op names', () => {
@@ -103,12 +104,8 @@ describe('createSemanticFacades', () => {
     expect(names).toContain('route_intent');
     expect(names).toContain('morph');
     expect(names).toContain('get_behavior_rules');
-    // Cognee
-    expect(names).toContain('cognee_status');
-    expect(names).toContain('cognee_search');
-    expect(names).toContain('cognee_add');
-    expect(names).toContain('cognee_cognify');
-    expect(names).toContain('cognee_config');
+    // Cognee — only present when cognee is enabled in runtime
+    // (this test creates runtime without cognee: true)
     // Context Engine (#172)
     expect(names).toContain('context_extract_entities');
     expect(names).toContain('context_retrieve_knowledge');
@@ -324,10 +321,7 @@ describe('createSemanticFacades', () => {
     // Prompt templates
     expect(names).toContain('render_prompt');
     expect(names).toContain('list_templates');
-    // Cognee Sync ops
-    expect(names).toContain('cognee_sync_status');
-    expect(names).toContain('cognee_sync_drain');
-    expect(names).toContain('cognee_sync_reconcile');
+    // Cognee Sync ops — only present when cognee is enabled
     // Intake ops
     expect(names).toContain('intake_ingest_book');
     expect(names).toContain('intake_process');
@@ -515,55 +509,9 @@ describe('createSemanticFacades', () => {
     expect(result.totalEntries).toBe(1);
   });
 
-  it('cognee_status should return health check result', async () => {
-    // Cognee is not running in tests — should degrade gracefully
-    const result = (await findOp('cognee_status').handler({})) as {
-      available: boolean;
-      url: string;
-    };
-    expect(typeof result.available).toBe('boolean');
-    expect(typeof result.url).toBe('string');
-  });
-
-  it('cognee_search should return empty when unavailable', async () => {
-    const results = (await findOp('cognee_search').handler({
-      query: 'test pattern',
-    })) as unknown[];
-    expect(results).toEqual([]);
-  });
-
-  it('cognee_add should return 0 when unavailable', async () => {
-    runtime.vault.seed([
-      {
-        id: 'cog-1',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Cognee test',
-        severity: 'warning',
-        description: 'Test.',
-        tags: ['test'],
-      },
-    ]);
-    const result = (await findOp('cognee_add').handler({
-      entryIds: ['cog-1'],
-    })) as { added: number };
-    expect(result.added).toBe(0);
-  });
-
-  it('cognee_cognify should return unavailable when Cognee is down', async () => {
-    const result = (await findOp('cognee_cognify').handler({})) as { status: string };
-    expect(result.status).toBe('unavailable');
-  });
-
-  it('cognee_config should return config and null status', async () => {
-    const result = (await findOp('cognee_config').handler({})) as {
-      config: { baseUrl: string; dataset: string };
-      cachedStatus: null;
-    };
-    expect(result.config.baseUrl).toBe('http://localhost:8000');
-    expect(result.config.dataset).toBe('test-core-ops');
-    expect(result.cachedStatus).toBeNull();
-  });
+  // Cognee ops are only registered when runtime has cognee enabled.
+  // This test creates runtime without cognee: true, so these ops are not present.
+  // See e2e/full-pipeline.test.ts for cognee facade tests with cognee enabled.
 
   it('llm_rotate should return rotation status', async () => {
     const result = (await findOp('llm_rotate').handler({ provider: 'openai' })) as {

package/src/__tests__/curator-extra-ops.test.ts

@@ -26,9 +26,9 @@ describe('createCuratorExtraOps', () => {
     ops = createCuratorExtraOps(runtime);
   }
 
-  it('should return 5 ops', () => {
+  it('should return 9 ops', () => {
     setup();
-    expect(ops).toHaveLength(5);
+    expect(ops).toHaveLength(9);
     const names = ops.map((o) => o.name);
     expect(names).toEqual([
       'curator_entry_history',
@@ -36,6 +36,10 @@ describe('createCuratorExtraOps', () => {
       'curator_queue_stats',
       'curator_enrich',
       'curator_hybrid_contradictions',
+      'curator_pipeline_status',
+      'curator_enqueue_pipeline',
+      'curator_schedule_start',
+      'curator_schedule_stop',
     ]);
   });
 

package/src/__tests__/curator-pipeline-e2e.test.ts

@@ -0,0 +1,358 @@
+/**
+ * E2E tests for curator async infrastructure (#210).
+ *
+ * Tests the full pipeline: enqueue → DAG resolution → handler dispatch → completion.
+ * Also tests quality gate and classifier graceful degradation (no LLM).
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Vault } from '../vault/vault.js';
+import { Brain } from '../brain/brain.js';
+import { Curator } from '../curator/curator.js';
+import { JobQueue } from '../queue/job-queue.js';
+import { PipelineRunner } from '../queue/pipeline-runner.js';
+import { TypedEventBus } from '../events/event-bus.js';
+import { LinkManager } from '../vault/linking.js';
+import { evaluateQuality } from '../curator/quality-gate.js';
+import { classifyEntry } from '../curator/classifier.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+// ─── Shared Setup ────────────────────────────────────────────────────
+
+let vault: Vault;
+let brain: Brain;
+let curator: Curator;
+let queue: JobQueue;
+let runner: PipelineRunner;
+let linkManager: LinkManager;
+
+const SEED: IntelligenceEntry[] = [
+  {
+    id: 'pattern-circuit-breaker',
+    type: 'pattern',
+    domain: 'architecture',
+    title: 'Circuit Breaker for External Services',
+    severity: 'critical',
+    description: 'Wrap external service calls in a circuit breaker to prevent cascade failures.',
+    tags: ['networking', 'resilience', 'microservices'],
+    why: 'Prevents one failing service from taking down the entire system.',
+  },
+  {
+    id: 'anti-pattern-no-timeout',
+    type: 'anti-pattern',
+    domain: 'architecture',
+    title: 'HTTP Calls Without Timeout',
+    severity: 'critical',
+    description: 'Never make HTTP calls without a timeout. Can hang indefinitely.',
+    tags: ['networking', 'timeout', 'http'],
+  },
+  {
+    id: 'pattern-semantic-tokens',
+    type: 'pattern',
+    domain: 'design',
+    title: 'Use Semantic Tokens',
+    severity: 'warning',
+    description: 'Prefer semantic tokens over primitive color values for maintainability.',
+    tags: ['tokens', 'design-system'],
+  },
+];
+
+beforeAll(() => {
+  vault = new Vault(':memory:');
+  vault.seed(SEED);
+  brain = new Brain(vault);
+  curator = new Curator(vault);
+  queue = new JobQueue(vault.getProvider());
+  linkManager = new LinkManager(vault.getProvider());
+  runner = new PipelineRunner(queue);
+
+  // Register handlers matching the runtime setup
+  runner.registerHandler('tag-normalize', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return curator.normalizeTag(entry.tags[0] ?? '');
+  });
+  runner.registerHandler('dedup-check', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return curator.detectDuplicates(entry.id);
+  });
+  runner.registerHandler('auto-link', async (job) => {
+    const suggestions = linkManager.suggestLinks(job.entryId ?? '', 3);
+    for (const s of suggestions) {
+      linkManager.addLink(job.entryId ?? '', s.entryId, s.suggestedType, `pipeline: ${s.reason}`);
+    }
+    return { linked: suggestions.length };
+  });
+  runner.registerHandler('quality-gate', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return evaluateQuality(entry, null); // No LLM in tests
+  });
+  runner.registerHandler('classify', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return classifyEntry(entry, null); // No LLM in tests
+  });
+});
+
+afterAll(() => {
+  runner.stop();
+  vault.close();
+});
+
+// ─── Job Queue Integration ──────────────────────────────────────────
+
+describe('Job Queue — curator pipeline', () => {
+  it('enqueues a 3-step DAG pipeline for an entry', () => {
+    const pipelineId = 'pipe-test-1';
+    const entryId = 'pattern-circuit-breaker';
+
+    const step1 = queue.enqueue('tag-normalize', { entryId, pipelineId });
+    const step2 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step1] });
+    const step3 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step2] });
+
+    const jobs = queue.getByPipeline(pipelineId);
+    expect(jobs.length).toBe(3);
+    expect(jobs[0].type).toBe('tag-normalize');
+    expect(jobs[1].dependsOn).toContain(step1);
+    expect(jobs[2].dependsOn).toContain(step2);
+  });
+
+  it('dequeueReady only returns jobs with completed deps', () => {
+    const pipelineId = 'pipe-test-dag';
+    const step1 = queue.enqueue('tag-normalize', {
+      entryId: 'pattern-circuit-breaker',
+      pipelineId,
+    });
+    const step2 = queue.enqueue('dedup-check', {
+      entryId: 'pattern-circuit-breaker',
+      pipelineId,
+      dependsOn: [step1],
+    });
+
+    // Only step1 should be ready
+    const ready = queue.dequeueReady(10);
+    const readyIds = ready.map((j) => j.id);
+    expect(readyIds).toContain(step1);
+    expect(readyIds).not.toContain(step2);
+  });
+});
+
+// ─── Pipeline Runner Integration ────────────────────────────────────
+
+describe('Pipeline Runner — full pipeline execution', () => {
+  it('executes a 3-step pipeline in DAG order', async () => {
+    const pipelineId = 'pipe-runner-test';
+    const entryId = 'pattern-circuit-breaker';
+
+    const step1 = queue.enqueue('tag-normalize', { entryId, pipelineId });
+    const step2 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step1] });
+    const step3 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step2] });
+
+    // Process step 1
+    const batch1 = await runner.processOnce(10);
+    expect(batch1).toBeGreaterThanOrEqual(1);
+    expect(queue.get(step1)!.status).toBe('completed');
+
+    // Process step 2
+    const batch2 = await runner.processOnce(10);
+    expect(batch2).toBeGreaterThanOrEqual(1);
+    expect(queue.get(step2)!.status).toBe('completed');
+
+    // Process step 3
+    const batch3 = await runner.processOnce(10);
+    expect(batch3).toBeGreaterThanOrEqual(1);
+    expect(queue.get(step3)!.status).toBe('completed');
+
+    // All jobs in pipeline should be completed
+    const jobs = queue.getByPipeline(pipelineId);
+    expect(jobs.every((j) => j.status === 'completed')).toBe(true);
+  });
+
+  it('tag-normalize handler returns normalization result', async () => {
+    const id = queue.enqueue('tag-normalize', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toBeDefined();
+  });
+
+  it('dedup-check handler detects duplicates', async () => {
+    const id = queue.enqueue('dedup-check', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toBeDefined();
+  });
+
+  it('auto-link handler creates Zettelkasten links', async () => {
+    const id = queue.enqueue('auto-link', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { linked: number };
+    expect(typeof result.linked).toBe('number');
+  });
+
+  it('handles missing entry gracefully', async () => {
+    const id = queue.enqueue('tag-normalize', { entryId: 'nonexistent-entry' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect((job!.result as Record<string, unknown>).skipped).toBe(true);
+  });
+
+  it('runner status tracks processed/failed counts', async () => {
+    const status = runner.getStatus();
+    expect(status.jobsProcessed).toBeGreaterThan(0);
+    expect(typeof status.jobsFailed).toBe('number');
+    expect(typeof status.jobsRetried).toBe('number');
+  });
+});
+
+// ─── Quality Gate (no LLM) ──────────────────────────────────────────
+
+describe('Quality Gate — graceful degradation', () => {
+  it('returns ACCEPT with default scores when no LLM', async () => {
+    const entry = vault.get('pattern-circuit-breaker')!;
+    const result = await evaluateQuality(entry, null);
+
+    expect(result.evaluated).toBe(false);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.overallScore).toBe(50);
+    expect(result.scores.novelty).toBe(50);
+    expect(result.scores.actionability).toBe(50);
+    expect(result.reasoning).toContain('unavailable');
+  });
+
+  it('quality-gate job handler works via pipeline', async () => {
+    const id = queue.enqueue('quality-gate', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { evaluated: boolean; verdict: string };
+    expect(result.verdict).toBe('ACCEPT');
+  });
+});
+
+// ─── Classifier (no LLM) ────────────────────────────────────────────
+
+describe('Classifier — graceful degradation', () => {
+  it('returns empty classification when no LLM', async () => {
+    const entry = vault.get('pattern-circuit-breaker')!;
+    const result = await classifyEntry(entry, null);
+
+    expect(result.classified).toBe(false);
+    expect(result.suggestedDomain).toBeNull();
+    expect(result.suggestedSeverity).toBeNull();
+    expect(result.suggestedTags).toEqual([]);
+    expect(result.confidence).toBe(0);
+  });
+
+  it('classify job handler works via pipeline', async () => {
+    const id = queue.enqueue('classify', { entryId: 'anti-pattern-no-timeout' });
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { classified: boolean };
+    expect(result.classified).toBe(false); // No LLM
+  });
+});
+
+// ─── Event Bus Integration ──────────────────────────────────────────
+
+describe('Event Bus — curator events', () => {
+  type CuratorEvents = {
+    'entry:captured': { id: string; title: string };
+    'pipeline:started': { pipelineId: string; entryId: string };
+    'pipeline:completed': { pipelineId: string; jobsCompleted: number };
+    'quality:rejected': { entryId: string; score: number; reasons: string[] };
+  };
+
+  it('fires entry:captured event and listeners receive it', () => {
+    const bus = new TypedEventBus<CuratorEvents>();
+    let received: CuratorEvents['entry:captured'] | null = null;
+
+    bus.on('entry:captured', (payload) => {
+      received = payload;
+    });
+    bus.emit('entry:captured', { id: 'test-1', title: 'Test Entry' });
+
+    expect(received).toEqual({ id: 'test-1', title: 'Test Entry' });
+  });
+
+  it('fires pipeline events in sequence', () => {
+    const bus = new TypedEventBus<CuratorEvents>();
+    const events: string[] = [];
+
+    bus.on('pipeline:started', () => events.push('started'));
+    bus.on('pipeline:completed', () => events.push('completed'));
+
+    bus.emit('pipeline:started', { pipelineId: 'p1', entryId: 'e1' });
+    bus.emit('pipeline:completed', { pipelineId: 'p1', jobsCompleted: 3 });
+
+    expect(events).toEqual(['started', 'completed']);
+  });
+
+  it('fires quality:rejected for low-scoring entries', () => {
+    const bus = new TypedEventBus<CuratorEvents>();
+    let rejected: CuratorEvents['quality:rejected'] | null = null;
+
+    bus.on('quality:rejected', (payload) => {
+      rejected = payload;
+    });
+    bus.emit('quality:rejected', {
+      entryId: 'junk-1',
+      score: 25,
+      reasons: ['too vague', 'no actionability'],
+    });
+
+    expect(rejected!.score).toBe(25);
+    expect(rejected!.reasons).toContain('too vague');
+  });
+});
+
+// ─── Full Pipeline E2E ──────────────────────────────────────────────
+
+describe('Full pipeline E2E — capture to completion', () => {
+  it('processes a 5-step pipeline: quality-gate → tag-normalize → dedup → classify → auto-link', async () => {
+    const entryId = 'anti-pattern-no-timeout';
+    const pipelineId = 'full-e2e';
+
+    const step1 = queue.enqueue('quality-gate', { entryId, pipelineId });
+    const step2 = queue.enqueue('tag-normalize', { entryId, pipelineId, dependsOn: [step1] });
+    const step3 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step2] });
+    const step4 = queue.enqueue('classify', { entryId, pipelineId, dependsOn: [step3] });
+    const step5 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step4] });
+
+    // Process all steps — run enough batches to drain DAG
+    // (earlier tests may have left pending jobs, so process generously)
+    for (let i = 0; i < 10; i++) {
+      await runner.processOnce(20);
+    }
+
+    const jobs = queue.getByPipeline(pipelineId);
+    const statuses = jobs.map((j) => `${j.type}:${j.status}`);
+
+    expect(statuses).toEqual([
+      'quality-gate:completed',
+      'tag-normalize:completed',
+      'dedup-check:completed',
+      'classify:completed',
+      'auto-link:completed',
+    ]);
+  });
+
+  it('queue stats reflect pipeline completion', () => {
+    const stats = queue.getStats();
+    expect(stats.completed).toBeGreaterThan(5);
+    expect(stats.total).toBeGreaterThan(10);
+  });
+});