@soleri/core 9.0.4 → 9.2.0

package/src/runtime/facades/agency-facade.test.ts

@@ -0,0 +1,278 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createAgencyFacadeOps } from './agency-facade.js';
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+
+function mockRuntime(): AgentRuntime {
+  return {
+    agencyManager: {
+      enable: vi.fn(),
+      disable: vi.fn(),
+      getStatus: vi.fn().mockReturnValue({ enabled: false, watching: false }),
+      updateConfig: vi.fn(),
+      scanFile: vi.fn().mockReturnValue([]),
+      getPendingWarnings: vi.fn().mockReturnValue([]),
+      surfacePatterns: vi.fn().mockReturnValue([]),
+      generateClarification: vi.fn(),
+      generateSuggestions: vi.fn().mockReturnValue([]),
+      generateRichClarification: vi.fn(),
+      suppressWarning: vi.fn(),
+      unsuppressWarning: vi.fn(),
+      dismissPattern: vi.fn(),
+      drainNotifications: vi.fn().mockReturnValue([]),
+      getFullStatus: vi.fn().mockReturnValue({ enabled: false }),
+    },
+  } as unknown as AgentRuntime;
+}
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op "${name}" not found`);
+  return op;
+}
+
+describe('createAgencyFacadeOps', () => {
+  let runtime: ReturnType<typeof mockRuntime>;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    runtime = mockRuntime();
+    ops = createAgencyFacadeOps(runtime);
+  });
+
+  it('returns all expected ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'agency_enable',
+      'agency_disable',
+      'agency_status',
+      'agency_config',
+      'agency_scan_file',
+      'agency_warnings',
+      'agency_surface_patterns',
+      'agency_clarify',
+      'agency_suggestions',
+      'agency_rich_clarify',
+      'agency_suppress_warning',
+      'agency_unsuppress_warning',
+      'agency_dismiss_pattern',
+      'agency_notifications',
+      'agency_full_status',
+    ]);
+  });
+
+  it('assigns correct auth levels', () => {
+    expect(findOp(ops, 'agency_enable').auth).toBe('write');
+    expect(findOp(ops, 'agency_disable').auth).toBe('write');
+    expect(findOp(ops, 'agency_status').auth).toBe('read');
+    expect(findOp(ops, 'agency_config').auth).toBe('write');
+    expect(findOp(ops, 'agency_scan_file').auth).toBe('read');
+    expect(findOp(ops, 'agency_warnings').auth).toBe('read');
+    expect(findOp(ops, 'agency_surface_patterns').auth).toBe('read');
+    expect(findOp(ops, 'agency_clarify').auth).toBe('read');
+    expect(findOp(ops, 'agency_suggestions').auth).toBe('read');
+    expect(findOp(ops, 'agency_rich_clarify').auth).toBe('read');
+    expect(findOp(ops, 'agency_suppress_warning').auth).toBe('write');
+    expect(findOp(ops, 'agency_unsuppress_warning').auth).toBe('write');
+    expect(findOp(ops, 'agency_dismiss_pattern').auth).toBe('write');
+    expect(findOp(ops, 'agency_notifications').auth).toBe('read');
+    expect(findOp(ops, 'agency_full_status').auth).toBe('read');
+  });
+
+  describe('agency_enable', () => {
+    it('enables with default project path', async () => {
+      const status = { enabled: true, watching: true };
+      vi.mocked(runtime.agencyManager.getStatus).mockReturnValue(status as never);
+
+      const result = await findOp(ops, 'agency_enable').handler({});
+      expect(runtime.agencyManager.enable).toHaveBeenCalledWith('.');
+      expect(result).toEqual(status);
+    });
+
+    it('enables with custom project path', async () => {
+      const status = { enabled: true, watching: true };
+      vi.mocked(runtime.agencyManager.getStatus).mockReturnValue(status as never);
+
+      await findOp(ops, 'agency_enable').handler({ projectPath: '/my/project' });
+      expect(runtime.agencyManager.enable).toHaveBeenCalledWith('/my/project');
+    });
+  });
+
+  describe('agency_disable', () => {
+    it('disables and returns status', async () => {
+      const status = { enabled: false, watching: false };
+      vi.mocked(runtime.agencyManager.getStatus).mockReturnValue(status as never);
+
+      const result = await findOp(ops, 'agency_disable').handler({});
+      expect(runtime.agencyManager.disable).toHaveBeenCalled();
+      expect(result).toEqual(status);
+    });
+  });
+
+  describe('agency_status', () => {
+    it('returns current status', async () => {
+      const status = { enabled: true, watching: true, detectors: 3 };
+      vi.mocked(runtime.agencyManager.getStatus).mockReturnValue(status as never);
+
+      const result = await findOp(ops, 'agency_status').handler({});
+      expect(result).toEqual(status);
+    });
+  });
+
+  describe('agency_config', () => {
+    it('updates config and returns status', async () => {
+      const config = { watchPaths: ['/src'], debounceMs: 500 };
+      const status = { enabled: true };
+      vi.mocked(runtime.agencyManager.getStatus).mockReturnValue(status as never);
+
+      const result = await findOp(ops, 'agency_config').handler(config);
+      expect(runtime.agencyManager.updateConfig).toHaveBeenCalledWith(config);
+      expect(result).toEqual(status);
+    });
+  });
+
+  describe('agency_scan_file', () => {
+    it('returns warnings and count', async () => {
+      const warnings = [{ id: 'w1', message: 'issue' }];
+      vi.mocked(runtime.agencyManager.scanFile).mockReturnValue(warnings as never);
+
+      const result = (await findOp(ops, 'agency_scan_file').handler({
+        filePath: '/src/foo.ts',
+      })) as { warnings: unknown[]; count: number };
+      expect(result.warnings).toEqual(warnings);
+      expect(result.count).toBe(1);
+    });
+
+    it('returns empty when no warnings', async () => {
+      vi.mocked(runtime.agencyManager.scanFile).mockReturnValue([] as never);
+
+      const result = (await findOp(ops, 'agency_scan_file').handler({
+        filePath: '/src/clean.ts',
+      })) as { warnings: unknown[]; count: number };
+      expect(result.count).toBe(0);
+    });
+  });
+
+  describe('agency_warnings', () => {
+    it('returns pending warnings', async () => {
+      const warnings = [{ id: 'w1' }, { id: 'w2' }];
+      vi.mocked(runtime.agencyManager.getPendingWarnings).mockReturnValue(warnings as never);
+
+      const result = (await findOp(ops, 'agency_warnings').handler({})) as {
+        warnings: unknown[];
+        count: number;
+      };
+      expect(result.count).toBe(2);
+    });
+  });
+
+  describe('agency_surface_patterns', () => {
+    it('returns patterns for a file', async () => {
+      const patterns = [{ id: 'p1', title: 'Pattern A' }];
+      vi.mocked(runtime.agencyManager.surfacePatterns).mockReturnValue(patterns as never);
+
+      const result = (await findOp(ops, 'agency_surface_patterns').handler({
+        filePath: '/src/comp.tsx',
+      })) as { patterns: unknown[]; count: number };
+      expect(result.patterns).toEqual(patterns);
+      expect(result.count).toBe(1);
+    });
+  });
+
+  describe('agency_clarify', () => {
+    it('returns clarification question when needed', async () => {
+      const question = { question: 'Did you mean...?', options: ['A', 'B'] };
+      vi.mocked(runtime.agencyManager.generateClarification).mockReturnValue(question as never);
+
+      const result = await findOp(ops, 'agency_clarify').handler({
+        prompt: 'fix the thing',
+        confidence: 0.3,
+      });
+      expect(result).toEqual(question);
+    });
+
+    it('returns clarificationNeeded:false when not needed', async () => {
+      vi.mocked(runtime.agencyManager.generateClarification).mockReturnValue(null as never);
+
+      const result = await findOp(ops, 'agency_clarify').handler({
+        prompt: 'build a button',
+        confidence: 0.9,
+      });
+      expect(result).toEqual({ clarificationNeeded: false });
+    });
+  });
+
+  describe('agency_suggestions', () => {
+    it('returns triggered suggestions', async () => {
+      const suggestions = [{ rule: 'lint', priority: 1 }];
+      vi.mocked(runtime.agencyManager.generateSuggestions).mockReturnValue(suggestions as never);
+
+      const result = await findOp(ops, 'agency_suggestions').handler({});
+      expect(result).toEqual(suggestions);
+    });
+  });
+
+  describe('agency_rich_clarify', () => {
+    it('returns structured clarification', async () => {
+      const rich = { questions: [{ text: 'What scope?', urgency: 'high' }] };
+      vi.mocked(runtime.agencyManager.generateRichClarification).mockReturnValue(rich as never);
+
+      const result = await findOp(ops, 'agency_rich_clarify').handler({
+        prompt: 'refactor something',
+      });
+      expect(result).toEqual(rich);
+    });
+  });
+
+  describe('agency_suppress_warning', () => {
+    it('suppresses and returns confirmation', async () => {
+      const result = (await findOp(ops, 'agency_suppress_warning').handler({
+        warningId: 'w1',
+      })) as Record<string, unknown>;
+      expect(result.suppressed).toBe(true);
+      expect(result.warningId).toBe('w1');
+      expect(runtime.agencyManager.suppressWarning).toHaveBeenCalledWith('w1');
+    });
+  });
+
+  describe('agency_unsuppress_warning', () => {
+    it('unsuppresses and returns confirmation', async () => {
+      const result = (await findOp(ops, 'agency_unsuppress_warning').handler({
+        warningId: 'w1',
+      })) as Record<string, unknown>;
+      expect(result.unsuppressed).toBe(true);
+      expect(result.warningId).toBe('w1');
+    });
+  });
+
+  describe('agency_dismiss_pattern', () => {
+    it('dismisses and returns ttl info', async () => {
+      const result = (await findOp(ops, 'agency_dismiss_pattern').handler({
+        entryId: 'e1',
+      })) as Record<string, unknown>;
+      expect(result.dismissed).toBe(true);
+      expect(result.entryId).toBe('e1');
+      expect(result.ttlHours).toBe(24);
+    });
+  });
+
+  describe('agency_notifications', () => {
+    it('drains notification queue', async () => {
+      const notifications = [{ type: 'warning', message: 'stale entry' }];
+      vi.mocked(runtime.agencyManager.drainNotifications).mockReturnValue(notifications as never);
+
+      const result = await findOp(ops, 'agency_notifications').handler({});
+      expect(result).toEqual(notifications);
+    });
+  });
+
+  describe('agency_full_status', () => {
+    it('returns full status', async () => {
+      const fullStatus = { enabled: true, suppressions: [], dismissals: [] };
+      vi.mocked(runtime.agencyManager.getFullStatus).mockReturnValue(fullStatus as never);
+
+      const result = await findOp(ops, 'agency_full_status').handler({});
+      expect(result).toEqual(fullStatus);
+    });
+  });
+});

package/src/runtime/facades/archive-facade.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Colocated contract tests for archive-facade.ts.
+ * Tests the archive facade dispatches to archive-ops correctly.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createArchiveFacadeOps } from './archive-facade.js';
+import { captureOps, executeOp } from '../../engine/test-helpers.js';
+import type { CapturedOp } from '../../engine/test-helpers.js';
+import type { AgentRuntime } from '../types.js';
+
+// ─── Mock factories ──────────────────────────────────────────────────
+
+function makeEntry(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'entry-1',
+    type: 'pattern',
+    domain: 'testing',
+    title: 'Test Pattern',
+    severity: 'suggestion',
+    description: 'A test pattern',
+    tags: ['test'],
+    ...overrides,
+  };
+}
+
+function makeMockVault() {
+  return {
+    get: vi.fn((id: string) => (id === 'entry-1' ? makeEntry() : null)),
+    update: vi.fn((id: string) => (id === 'entry-1' ? makeEntry() : null)),
+    remove: vi.fn().mockReturnValue(true),
+    list: vi.fn().mockReturnValue([makeEntry()]),
+    stats: vi.fn().mockReturnValue({ totalEntries: 10, byDomain: { testing: 5 } }),
+    getTags: vi.fn().mockReturnValue([
+      { tag: 'test', count: 5 },
+      { tag: 'design', count: 3 },
+    ]),
+    getDomains: vi.fn().mockReturnValue([
+      { domain: 'testing', count: 5 },
+      { domain: 'design', count: 3 },
+    ]),
+    exportAll: vi.fn().mockReturnValue({ entries: [makeEntry()], exportedAt: Date.now() }),
+    getAgeReport: vi.fn().mockReturnValue({
+      buckets: [
+        { label: 'today', count: 2 },
+        { label: 'this_week', count: 3 },
+        { label: 'this_month', count: 2 },
+        { label: 'this_quarter', count: 1 },
+        { label: 'older', count: 2 },
+      ],
+      oldestTimestamp: 1700000000,
+      newestTimestamp: Date.now(),
+    }),
+    getDb: vi.fn().mockReturnValue({
+      prepare: vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([{ tag: 'auth', type_count: 2 }]),
+      }),
+    }),
+    setTemporal: vi.fn().mockReturnValue(true),
+    findExpiring: vi.fn().mockReturnValue([makeEntry()]),
+    findExpired: vi.fn().mockReturnValue([makeEntry()]),
+    archive: vi.fn().mockReturnValue({ archived: 3, reason: 'cleanup' }),
+    restore: vi.fn().mockReturnValue(true),
+    optimize: vi.fn().mockReturnValue({ vacuumed: true, analyzed: true, ftsRebuilt: true }),
+  };
+}
+
+function makeRuntime(): AgentRuntime {
+  return {
+    vault: makeMockVault(),
+  } as unknown as AgentRuntime;
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────
+
+describe('archive-facade', () => {
+  let runtime: AgentRuntime;
+  let ops: Map<string, CapturedOp>;
+
+  beforeEach(() => {
+    runtime = makeRuntime();
+    ops = captureOps(createArchiveFacadeOps(runtime));
+  });
+
+  // ─── Registration ─────────────────────────────────────────────────
+
+  it('registers 12 ops', () => {
+    expect(ops.size).toBe(12);
+  });
+
+  it('includes all expected op names', () => {
+    const expected = [
+      'vault_archive', 'vault_restore', 'vault_optimize', 'vault_backup',
+      'vault_age_report', 'vault_set_temporal', 'vault_find_expiring', 'vault_find_expired',
+      'knowledge_audit', 'knowledge_health', 'knowledge_merge', 'knowledge_reorganize',
+    ];
+    for (const name of expected) {
+      expect(ops.has(name), `missing op: ${name}`).toBe(true);
+    }
+  });
+
+  // ─── Auth levels ─────────────────────────────────────────────────
+
+  it('has correct auth levels', () => {
+    expect(ops.get('vault_archive')!.auth).toBe('write');
+    expect(ops.get('vault_restore')!.auth).toBe('write');
+    expect(ops.get('vault_optimize')!.auth).toBe('write');
+    expect(ops.get('vault_backup')!.auth).toBe('read');
+    expect(ops.get('vault_age_report')!.auth).toBe('read');
+    expect(ops.get('vault_set_temporal')!.auth).toBe('write');
+    expect(ops.get('vault_find_expiring')!.auth).toBe('read');
+    expect(ops.get('vault_find_expired')!.auth).toBe('read');
+    expect(ops.get('knowledge_audit')!.auth).toBe('read');
+    expect(ops.get('knowledge_health')!.auth).toBe('read');
+    expect(ops.get('knowledge_merge')!.auth).toBe('write');
+    expect(ops.get('knowledge_reorganize')!.auth).toBe('write');
+  });
+
+  // ─── vault_archive ──────────────────────────────────────────────
+
+  describe('vault_archive', () => {
+    it('archives old entries', async () => {
+      const result = await executeOp(ops, 'vault_archive', {
+        olderThanDays: 90, reason: 'cleanup',
+      });
+      expect(result.success).toBe(true);
+      const vault = runtime.vault as ReturnType<typeof makeMockVault>;
+      expect(vault.archive).toHaveBeenCalledWith({ olderThanDays: 90, reason: 'cleanup' });
+    });
+  });
+
+  // ─── vault_restore ──────────────────────────────────────────────
+
+  describe('vault_restore', () => {
+    it('restores archived entry', async () => {
+      const result = await executeOp(ops, 'vault_restore', { id: 'entry-1' });
+      expect(result.success).toBe(true);
+      const data = result.data as { restored: boolean; id: string };
+      expect(data.restored).toBe(true);
+    });
+  });
+
+  // ─── vault_optimize ──────────────────────────────────────────────
+
+  describe('vault_optimize', () => {
+    it('optimizes database', async () => {
+      const result = await executeOp(ops, 'vault_optimize', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { vacuumed: boolean };
+      expect(data.vacuumed).toBe(true);
+    });
+  });
+
+  // ─── vault_backup ────────────────────────────────────────────────
+
+  describe('vault_backup', () => {
+    it('exports full vault', async () => {
+      const result = await executeOp(ops, 'vault_backup', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { entries: unknown[] };
+      expect(data.entries).toBeDefined();
+    });
+  });
+
+  // ─── vault_age_report ────────────────────────────────────────────
+
+  describe('vault_age_report', () => {
+    it('returns age distribution', async () => {
+      const result = await executeOp(ops, 'vault_age_report', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { buckets: unknown[] };
+      expect(data.buckets).toBeDefined();
+    });
+  });
+
+  // ─── vault_set_temporal ──────────────────────────────────────────
+
+  describe('vault_set_temporal', () => {
+    it('sets temporal fields', async () => {
+      const result = await executeOp(ops, 'vault_set_temporal', {
+        id: 'entry-1', validFrom: 1000, validUntil: 2000,
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { updated: boolean };
+      expect(data.updated).toBe(true);
+    });
+
+    it('returns error when entry not found', async () => {
+      const vault = runtime.vault as ReturnType<typeof makeMockVault>;
+      vault.setTemporal.mockReturnValue(false);
+      const result = await executeOp(ops, 'vault_set_temporal', { id: 'x' });
+      expect(result.success).toBe(true);
+      const data = result.data as { error: string };
+      expect(data.error).toContain('not found');
+    });
+  });
+
+  // ─── vault_find_expiring ─────────────────────────────────────────
+
+  describe('vault_find_expiring', () => {
+    it('finds entries expiring within days', async () => {
+      const result = await executeOp(ops, 'vault_find_expiring', { withinDays: 7 });
+      expect(result.success).toBe(true);
+      const data = result.data as { count: number };
+      expect(data.count).toBe(1);
+    });
+  });
+
+  // ─── vault_find_expired ──────────────────────────────────────────
+
+  describe('vault_find_expired', () => {
+    it('finds expired entries', async () => {
+      const result = await executeOp(ops, 'vault_find_expired', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { count: number };
+      expect(data.count).toBe(1);
+    });
+  });
+
+  // ─── knowledge_audit ─────────────────────────────────────────────
+
+  describe('knowledge_audit', () => {
+    it('returns audit with recommendations', async () => {
+      const result = await executeOp(ops, 'knowledge_audit', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { totalEntries: number; recommendations: string[] };
+      expect(data.totalEntries).toBe(10);
+      expect(Array.isArray(data.recommendations)).toBe(true);
+    });
+  });
+
+  // ─── knowledge_health ────────────────────────────────────────────
+
+  describe('knowledge_health', () => {
+    it('returns health metrics', async () => {
+      const result = await executeOp(ops, 'knowledge_health', {});
+      expect(result.success).toBe(true);
+      const data = result.data as { totalEntries: number; contradictionSignals: number };
+      expect(data.totalEntries).toBe(10);
+      expect(data.contradictionSignals).toBe(1);
+    });
+  });
+
+  // ─── knowledge_merge ─────────────────────────────────────────────
+
+  describe('knowledge_merge', () => {
+    it('merges two entries', async () => {
+      const vault = runtime.vault as ReturnType<typeof makeMockVault>;
+      vault.get
+        .mockReturnValueOnce(makeEntry({ id: 'keep', tags: ['a'] }))
+        .mockReturnValueOnce(makeEntry({ id: 'remove', tags: ['b'] }));
+
+      const result = await executeOp(ops, 'knowledge_merge', {
+        keepId: 'keep', removeId: 'remove',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { merged: boolean; keptId: string };
+      expect(data.merged).toBe(true);
+      expect(data.keptId).toBe('keep');
+    });
+
+    it('returns error when entry not found', async () => {
+      const vault = runtime.vault as ReturnType<typeof makeMockVault>;
+      vault.get.mockReturnValue(null);
+      const result = await executeOp(ops, 'knowledge_merge', {
+        keepId: 'x', removeId: 'y',
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { error: string };
+      expect(data.error).toContain('not found');
+    });
+  });
+
+  // ─── knowledge_reorganize ─────────────────────────────────────────
+
+  describe('knowledge_reorganize', () => {
+    it('dry run reports changes', async () => {
+      const vault = runtime.vault as ReturnType<typeof makeMockVault>;
+      vault.list.mockReturnValue([
+        makeEntry({ id: 'e1', domain: 'old-domain', tags: ['old-tag'] }),
+      ]);
+      const result = await executeOp(ops, 'knowledge_reorganize', {
+        dryRun: true,
+        domainRules: [{ from: 'old-domain', to: 'new-domain' }],
+        retagRules: [{ from: 'old-tag', to: 'new-tag' }],
+      });
+      expect(result.success).toBe(true);
+      const data = result.data as { dryRun: boolean; changesFound: number };
+      expect(data.dryRun).toBe(true);
+      expect(data.changesFound).toBe(2);
+      expect(vault.update).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/runtime/facades/archive-facade.ts

@@ -0,0 +1,14 @@
+/**
+ * Archive facade — archival, lifecycle, and knowledge maintenance ops.
+ * vault_archive, vault_restore, vault_optimize, vault_backup,
+ * vault_age_report, vault_set_temporal, vault_find_expiring, vault_find_expired,
+ * knowledge_audit, knowledge_health, knowledge_merge, knowledge_reorganize.
+ */
+
+import type { OpDefinition } from '../../facades/types.js';
+import type { AgentRuntime } from '../types.js';
+import { createArchiveOps } from '../archive-ops.js';
+
+export function createArchiveFacadeOps(runtime: AgentRuntime): OpDefinition[] {
+  return createArchiveOps(runtime);
+}