@soleri/core 2.1.0 → 2.5.0

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

@@ -34,8 +34,8 @@ describe('createCoreOps', () => {
     return op;
   }
 
-  it('should return 37 ops', () => {
-    expect(ops.length).toBe(37);
+  it('should return 203 ops', () => {
+    expect(ops.length).toBe(203);
   });
 
   it('should have all expected op names', () => {
@@ -60,6 +60,8 @@ describe('createCoreOps', () => {
     expect(names).toContain('complete_plan');
     // Brain
     expect(names).toContain('record_feedback');
+    expect(names).toContain('brain_feedback');
+    expect(names).toContain('brain_feedback_stats');
     expect(names).toContain('rebuild_vocabulary');
     expect(names).toContain('brain_stats');
     expect(names).toContain('llm_status');
@@ -75,6 +77,9 @@ describe('createCoreOps', () => {
     expect(names).toContain('brain_archive_sessions');
     expect(names).toContain('brain_promote_proposals');
     expect(names).toContain('brain_lifecycle');
+    expect(names).toContain('brain_reset_extracted');
+    // Brain decay report (#89)
+    expect(names).toContain('brain_decay_report');
     // Curator
     expect(names).toContain('curator_status');
     expect(names).toContain('curator_detect_duplicates');
@@ -84,6 +89,158 @@ describe('createCoreOps', () => {
     expect(names).toContain('curator_groom_all');
     expect(names).toContain('curator_consolidate');
     expect(names).toContain('curator_health_audit');
+    // Control
+    expect(names).toContain('get_identity');
+    expect(names).toContain('update_identity');
+    expect(names).toContain('add_guideline');
+    expect(names).toContain('remove_guideline');
+    expect(names).toContain('rollback_identity');
+    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');
+    // LLM
+    expect(names).toContain('llm_rotate');
+    expect(names).toContain('llm_call');
+    // Governance
+    expect(names).toContain('governance_policy');
+    expect(names).toContain('governance_proposals');
+    expect(names).toContain('governance_stats');
+    expect(names).toContain('governance_expire');
+    expect(names).toContain('governance_dashboard');
+    // Playbook (5)
+    expect(names).toContain('playbook_list');
+    expect(names).toContain('playbook_get');
+    expect(names).toContain('playbook_match');
+    expect(names).toContain('playbook_seed');
+    expect(names).toContain('playbook_create');
+    // Planning Extra (9)
+    expect(names).toContain('plan_iterate');
+    expect(names).toContain('plan_split');
+    expect(names).toContain('plan_reconcile');
+    expect(names).toContain('plan_complete_lifecycle');
+    expect(names).toContain('plan_dispatch');
+    expect(names).toContain('plan_review');
+    expect(names).toContain('plan_archive');
+    expect(names).toContain('plan_list_tasks');
+    expect(names).toContain('plan_stats');
+    // Memory Extra (8)
+    expect(names).toContain('memory_delete');
+    expect(names).toContain('memory_stats');
+    expect(names).toContain('memory_export');
+    expect(names).toContain('memory_import');
+    expect(names).toContain('memory_prune');
+    expect(names).toContain('memory_deduplicate');
+    expect(names).toContain('memory_topics');
+    expect(names).toContain('memory_by_project');
+    // Vault Extra (12 + 3 temporal)
+    expect(names).toContain('vault_get');
+    expect(names).toContain('vault_update');
+    expect(names).toContain('vault_remove');
+    expect(names).toContain('vault_bulk_add');
+    expect(names).toContain('vault_bulk_remove');
+    expect(names).toContain('vault_tags');
+    expect(names).toContain('vault_domains');
+    expect(names).toContain('vault_recent');
+    expect(names).toContain('vault_import');
+    expect(names).toContain('vault_seed');
+    expect(names).toContain('vault_backup');
+    expect(names).toContain('vault_age_report');
+    // #89: Bi-temporal
+    expect(names).toContain('vault_set_temporal');
+    expect(names).toContain('vault_find_expiring');
+    expect(names).toContain('vault_find_expired');
+    // Admin (8)
+    expect(names).toContain('admin_health');
+    expect(names).toContain('admin_tool_list');
+    expect(names).toContain('admin_config');
+    expect(names).toContain('admin_vault_size');
+    expect(names).toContain('admin_uptime');
+    expect(names).toContain('admin_version');
+    expect(names).toContain('admin_reset_cache');
+    expect(names).toContain('admin_diagnostic');
+    // Admin Extra (10)
+    expect(names).toContain('admin_telemetry');
+    expect(names).toContain('admin_telemetry_recent');
+    expect(names).toContain('admin_telemetry_reset');
+    expect(names).toContain('admin_permissions');
+    expect(names).toContain('admin_vault_analytics');
+    expect(names).toContain('admin_search_insights');
+    expect(names).toContain('admin_module_status');
+    expect(names).toContain('admin_env');
+    expect(names).toContain('admin_gc');
+    expect(names).toContain('admin_export_config');
+    // Loop (7)
+    expect(names).toContain('loop_start');
+    expect(names).toContain('loop_iterate');
+    expect(names).toContain('loop_status');
+    expect(names).toContain('loop_cancel');
+    expect(names).toContain('loop_history');
+    expect(names).toContain('loop_is_active');
+    expect(names).toContain('loop_complete');
+    // Orchestrate (5)
+    expect(names).toContain('orchestrate_plan');
+    expect(names).toContain('orchestrate_execute');
+    expect(names).toContain('orchestrate_complete');
+    expect(names).toContain('orchestrate_status');
+    expect(names).toContain('orchestrate_quick_capture');
+    // Grading (5)
+    expect(names).toContain('plan_grade');
+    expect(names).toContain('plan_check_history');
+    expect(names).toContain('plan_latest_check');
+    expect(names).toContain('plan_meets_grade');
+    expect(names).toContain('plan_auto_improve');
+    // Capture (4)
+    expect(names).toContain('capture_knowledge');
+    expect(names).toContain('capture_quick');
+    expect(names).toContain('search_intelligent');
+    expect(names).toContain('search_feedback');
+    // Curator Extra (4 + 1 hybrid)
+    expect(names).toContain('curator_entry_history');
+    expect(names).toContain('curator_record_snapshot');
+    expect(names).toContain('curator_queue_stats');
+    expect(names).toContain('curator_enrich');
+    // #36: Hybrid contradiction detection
+    expect(names).toContain('curator_hybrid_contradictions');
+    // Project (12)
+    expect(names).toContain('project_get');
+    expect(names).toContain('project_list');
+    expect(names).toContain('project_unregister');
+    expect(names).toContain('project_get_rules');
+    expect(names).toContain('project_list_rules');
+    expect(names).toContain('project_add_rule');
+    expect(names).toContain('project_remove_rule');
+    expect(names).toContain('project_link');
+    expect(names).toContain('project_unlink');
+    expect(names).toContain('project_get_links');
+    expect(names).toContain('project_linked_projects');
+    expect(names).toContain('project_touch');
+    // 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');
+    // Intake ops
+    expect(names).toContain('intake_ingest_book');
+    expect(names).toContain('intake_process');
+    expect(names).toContain('intake_status');
+    expect(names).toContain('intake_preview');
+  });
+
+  it('register should include governance summary', async () => {
+    const result = (await findOp('register').handler({ projectPath: '/tmp/test-gov-reg' })) as {
+      governance: { pendingProposals: number; quotaPercent: number; isQuotaWarning: boolean };
+    };
+    expect(typeof result.governance.pendingProposals).toBe('number');
+    expect(typeof result.governance.quotaPercent).toBe('number');
+    expect(typeof result.governance.isQuotaWarning).toBe('boolean');
   });
 
   it('search should query vault via brain', async () => {
@@ -196,6 +353,47 @@ describe('createCoreOps', () => {
     expect(results.length).toBeGreaterThan(0);
   });
 
+  it('brain_feedback should record enhanced feedback', async () => {
+    runtime.vault.seed([
+      {
+        id: 'bf-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Brain feedback test',
+        severity: 'warning',
+        description: 'Test.',
+        tags: ['test'],
+      },
+    ]);
+    ops = createCoreOps(runtime);
+    const result = (await findOp('brain_feedback').handler({
+      query: 'test',
+      entryId: 'bf-1',
+      action: 'modified',
+      source: 'recommendation',
+      confidence: 0.8,
+    })) as { id: number; action: string; source: string };
+    expect(result.id).toBeGreaterThan(0);
+    expect(result.action).toBe('modified');
+    expect(result.source).toBe('recommendation');
+  });
+
+  it('brain_feedback_stats should return stats', async () => {
+    const stats = (await findOp('brain_feedback_stats').handler({})) as {
+      total: number;
+      acceptanceRate: number;
+    };
+    expect(typeof stats.total).toBe('number');
+    expect(typeof stats.acceptanceRate).toBe('number');
+  });
+
+  it('brain_reset_extracted should return reset count', async () => {
+    const result = (await findOp('brain_reset_extracted').handler({ all: true })) as {
+      reset: number;
+    };
+    expect(typeof result.reset).toBe('number');
+  });
+
   it('export should return bundles', async () => {
     runtime.vault.seed([
       {
@@ -215,4 +413,96 @@ describe('createCoreOps', () => {
     expect(result.exported).toBe(true);
     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();
+  });
+
+  it('llm_rotate should return rotation status', async () => {
+    const result = (await findOp('llm_rotate').handler({ provider: 'openai' })) as {
+      rotated?: boolean;
+      poolSize?: number;
+      error?: string;
+    };
+    // Either reports no keys or successfully rotates
+    expect(typeof result.rotated === 'boolean' || typeof result.error === 'string').toBe(true);
+  });
+
+  it('governance_policy get should return defaults', async () => {
+    const result = (await findOp('governance_policy').handler({
+      action: 'get',
+      projectPath: '/test',
+    })) as { quotas: { maxEntriesTotal: number } };
+    expect(result.quotas.maxEntriesTotal).toBe(500);
+  });
+
+  it('governance_stats should return quota and proposal stats', async () => {
+    const result = (await findOp('governance_stats').handler({
+      projectPath: '/test',
+    })) as {
+      quotaStatus: { total: number };
+      proposalStats: { total: number };
+    };
+    expect(typeof result.quotaStatus.total).toBe('number');
+    expect(typeof result.proposalStats.total).toBe('number');
+  });
+
+  it('governance_dashboard should return combined view', async () => {
+    const result = (await findOp('governance_dashboard').handler({
+      projectPath: '/test',
+    })) as {
+      vaultSize: number;
+      quotaPercent: number;
+      pendingProposals: number;
+    };
+    expect(typeof result.vaultSize).toBe('number');
+    expect(typeof result.quotaPercent).toBe('number');
+    expect(result.pendingProposals).toBe(0);
+  });
 });