@soleri/core 2.1.0 → 2.4.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 147 ops', () => {
+    expect(ops.length).toBe(147);
   });
 
   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,7 @@ 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');
     // Curator
     expect(names).toContain('curator_status');
     expect(names).toContain('curator_detect_duplicates');
@@ -84,6 +87,134 @@ 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');
+    // 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)
+    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');
+    // 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)
+    expect(names).toContain('curator_entry_history');
+    expect(names).toContain('curator_record_snapshot');
+    expect(names).toContain('curator_queue_stats');
+    expect(names).toContain('curator_enrich');
+    // 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');
+  });
+
+  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 +327,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 +387,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);
+  });
 });

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

@@ -0,0 +1,359 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createCuratorExtraOps } from '../runtime/curator-extra-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createCuratorExtraOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  afterEach(() => {
+    runtime?.close();
+  });
+
+  function setup() {
+    runtime = createAgentRuntime({
+      agentId: 'test-curator-extra',
+      vaultPath: ':memory:',
+    });
+    ops = createCuratorExtraOps(runtime);
+  }
+
+  it('should return 4 ops', () => {
+    setup();
+    expect(ops).toHaveLength(4);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'curator_entry_history',
+      'curator_record_snapshot',
+      'curator_queue_stats',
+      'curator_enrich',
+    ]);
+  });
+
+  // ─── curator_record_snapshot ───────────────────────────────────
+
+  describe('curator_record_snapshot', () => {
+    it('should record a snapshot and return historyId', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'snap-1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Snapshot Test',
+          severity: 'warning',
+          description: 'A test entry for snapshots.',
+          tags: ['test'],
+        },
+      ]);
+      const result = (await findOp('curator_record_snapshot').handler({
+        entryId: 'snap-1',
+        changedBy: 'user',
+        changeReason: 'manual snapshot',
+      })) as { recorded: boolean; historyId: number };
+
+      expect(result.recorded).toBe(true);
+      expect(result.historyId).toBeGreaterThan(0);
+    });
+
+    it('should return recorded false for missing entry', async () => {
+      setup();
+      const result = (await findOp('curator_record_snapshot').handler({
+        entryId: 'nonexistent',
+      })) as { recorded: boolean; historyId: number };
+
+      expect(result.recorded).toBe(false);
+      expect(result.historyId).toBe(-1);
+    });
+  });
+
+  // ─── curator_entry_history ─────────────────────────────────────
+
+  describe('curator_entry_history', () => {
+    it('should return version history with 2 snapshots in order', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'hist-1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'History Test',
+          severity: 'warning',
+          description: 'Entry for history test.',
+          tags: ['test'],
+        },
+      ]);
+
+      // Record two snapshots
+      runtime.curator.recordSnapshot('hist-1', 'user', 'first snapshot');
+      runtime.curator.recordSnapshot('hist-1', 'system', 'second snapshot');
+
+      const result = (await findOp('curator_entry_history').handler({
+        entryId: 'hist-1',
+      })) as {
+        entryId: string;
+        history: Array<{
+          historyId: number;
+          entryId: string;
+          snapshot: { title: string };
+          changedBy: string;
+          changeReason: string | null;
+          createdAt: number;
+        }>;
+        count: number;
+      };
+
+      expect(result.entryId).toBe('hist-1');
+      expect(result.count).toBe(2);
+      expect(result.history).toHaveLength(2);
+      // First snapshot first (ASC order)
+      expect(result.history[0].changedBy).toBe('user');
+      expect(result.history[0].changeReason).toBe('first snapshot');
+      expect(result.history[0].snapshot.title).toBe('History Test');
+      expect(result.history[1].changedBy).toBe('system');
+      expect(result.history[1].changeReason).toBe('second snapshot');
+    });
+
+    it('should return empty history for entry with no snapshots', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'hist-2',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'No History',
+          severity: 'warning',
+          description: 'Entry with no history.',
+          tags: ['test'],
+        },
+      ]);
+
+      const result = (await findOp('curator_entry_history').handler({
+        entryId: 'hist-2',
+      })) as { count: number };
+
+      expect(result.count).toBe(0);
+    });
+  });
+
+  // ─── curator_queue_stats ───────────────────────────────────────
+
+  describe('curator_queue_stats', () => {
+    it('should return correct grooming stats', async () => {
+      setup();
+      // Seed 3 entries
+      runtime.vault.seed([
+        {
+          id: 'qs-1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Queue A',
+          severity: 'warning',
+          description: 'Test.',
+          tags: ['test'],
+        },
+        {
+          id: 'qs-2',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Queue B',
+          severity: 'warning',
+          description: 'Test.',
+          tags: ['test'],
+        },
+        {
+          id: 'qs-3',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Queue C',
+          severity: 'warning',
+          description: 'Test.',
+          tags: ['test'],
+        },
+      ]);
+
+      // Groom only 2 of the 3
+      runtime.curator.groomEntry('qs-1');
+      runtime.curator.groomEntry('qs-2');
+
+      const result = (await findOp('curator_queue_stats').handler({})) as {
+        totalEntries: number;
+        groomedEntries: number;
+        ungroomedEntries: number;
+        staleEntries: number;
+        freshEntries: number;
+        avgDaysSinceGroom: number;
+      };
+
+      expect(result.totalEntries).toBe(3);
+      expect(result.groomedEntries).toBe(2);
+      expect(result.ungroomedEntries).toBe(1);
+      // Just groomed, so they should be fresh
+      expect(result.freshEntries).toBe(2);
+      expect(result.staleEntries).toBe(0);
+      expect(result.avgDaysSinceGroom).toBeGreaterThanOrEqual(0);
+      expect(result.avgDaysSinceGroom).toBeLessThan(1);
+    });
+
+    it('should return zeroes for empty vault', async () => {
+      setup();
+      const result = (await findOp('curator_queue_stats').handler({})) as {
+        totalEntries: number;
+        groomedEntries: number;
+        ungroomedEntries: number;
+      };
+
+      expect(result.totalEntries).toBe(0);
+      expect(result.groomedEntries).toBe(0);
+      expect(result.ungroomedEntries).toBe(0);
+    });
+  });
+
+  // ─── curator_enrich ────────────────────────────────────────────
+
+  describe('curator_enrich', () => {
+    it('should enrich entry with messy metadata', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'enrich-1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'avoid using any types',
+          severity: 'suggestion',
+          description: '  You should avoid using any types in TypeScript.  ',
+          tags: ['TypeScript', ' testing ', 'typescript'],
+        },
+      ]);
+
+      const result = (await findOp('curator_enrich').handler({
+        entryId: 'enrich-1',
+      })) as {
+        enriched: boolean;
+        changes: Array<{ field: string; before: string; after: string }>;
+      };
+
+      expect(result.enriched).toBe(true);
+      expect(result.changes.length).toBeGreaterThan(0);
+
+      // Check specific changes
+      const fieldNames = result.changes.map((c) => c.field);
+
+      // Title should be capitalized
+      expect(fieldNames).toContain('title');
+      const titleChange = result.changes.find((c) => c.field === 'title')!;
+      expect(titleChange.after).toBe('Avoid using any types');
+
+      // Tags should be normalized (lowercase, trimmed, deduped)
+      expect(fieldNames).toContain('tags');
+      const tagChange = result.changes.find((c) => c.field === 'tags')!;
+      const normalizedTags = JSON.parse(tagChange.after);
+      expect(normalizedTags).toEqual(['typescript', 'testing']);
+
+      // Type should be inferred as anti-pattern (starts with "avoid")
+      expect(fieldNames).toContain('type');
+      const typeChange = result.changes.find((c) => c.field === 'type')!;
+      expect(typeChange.after).toBe('anti-pattern');
+
+      // Description should be trimmed
+      expect(fieldNames).toContain('description');
+      const descChange = result.changes.find((c) => c.field === 'description')!;
+      expect(descChange.after).toBe('You should avoid using any types in TypeScript.');
+
+      // Verify the entry was actually updated in the vault
+      const updated = runtime.vault.get('enrich-1');
+      expect(updated).not.toBeNull();
+      expect(updated!.type).toBe('anti-pattern');
+      expect(updated!.title).toBe('Avoid using any types');
+
+      // Verify a snapshot was recorded
+      const history = runtime.curator.getVersionHistory('enrich-1');
+      expect(history.length).toBeGreaterThan(0);
+    });
+
+    it('should return enriched false for clean entry', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'enrich-2',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Clean entry with proper metadata',
+          severity: 'warning',
+          description: 'This entry is already clean.',
+          tags: ['clean', 'testing'],
+        },
+      ]);
+
+      const result = (await findOp('curator_enrich').handler({
+        entryId: 'enrich-2',
+      })) as {
+        enriched: boolean;
+        changes: Array<{ field: string; before: string; after: string }>;
+      };
+
+      expect(result.enriched).toBe(false);
+      expect(result.changes).toEqual([]);
+    });
+
+    it('should return enriched false for missing entry', async () => {
+      setup();
+      const result = (await findOp('curator_enrich').handler({
+        entryId: 'nonexistent',
+      })) as { enriched: boolean };
+
+      expect(result.enriched).toBe(false);
+    });
+
+    it('should infer severity from critical keywords', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'enrich-3',
+          type: 'rule',
+          domain: 'security',
+          title: 'Never expose API keys',
+          severity: 'suggestion',
+          description: 'API keys must not be committed to version control.',
+          tags: ['security'],
+        },
+      ]);
+
+      const result = (await findOp('curator_enrich').handler({
+        entryId: 'enrich-3',
+      })) as {
+        enriched: boolean;
+        changes: Array<{ field: string; before: string; after: string }>;
+      };
+
+      expect(result.enriched).toBe(true);
+      const severityChange = result.changes.find((c) => c.field === 'severity');
+      expect(severityChange).toBeDefined();
+      expect(severityChange!.after).toBe('critical');
+    });
+  });
+
+  // ─── Auth levels ───────────────────────────────────────────────
+
+  describe('auth levels', () => {
+    it('should use read auth for query ops', () => {
+      setup();
+      expect(findOp('curator_entry_history').auth).toBe('read');
+      expect(findOp('curator_queue_stats').auth).toBe('read');
+    });
+
+    it('should use write auth for mutation ops', () => {
+      setup();
+      expect(findOp('curator_record_snapshot').auth).toBe('write');
+      expect(findOp('curator_enrich').auth).toBe('write');
+    });
+  });
+});