@soleri/core 2.1.0 → 2.4.0

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

@@ -0,0 +1,407 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createVaultExtraOps } from '../runtime/vault-extra-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+function makeEntry(overrides: Partial<IntelligenceEntry> & { id: string }): IntelligenceEntry {
+  return {
+    type: 'pattern',
+    domain: 'testing',
+    title: 'Test entry',
+    severity: 'warning',
+    description: 'A test entry.',
+    tags: ['test'],
+    ...overrides,
+  };
+}
+
+describe('createVaultExtraOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let plannerDir: string;
+
+  beforeEach(() => {
+    plannerDir = join(tmpdir(), 'vault-extra-ops-test-' + Date.now());
+    mkdirSync(plannerDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'test-vault-extra',
+      vaultPath: ':memory:',
+      plansPath: join(plannerDir, 'plans.json'),
+    });
+    ops = createVaultExtraOps(runtime);
+  });
+
+  afterEach(() => {
+    runtime.close();
+    rmSync(plannerDir, { recursive: true, force: true });
+  });
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  it('should return 12 ops', () => {
+    expect(ops.length).toBe(12);
+  });
+
+  it('should have all expected op names', () => {
+    const names = ops.map((o) => o.name);
+    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');
+  });
+
+  // ─── vault_get ────────────────────────────────────────────────────
+
+  it('vault_get should return entry when found', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vg-1', title: 'Get test' })]);
+    const result = (await findOp('vault_get').handler({ id: 'vg-1' })) as IntelligenceEntry;
+    expect(result.id).toBe('vg-1');
+    expect(result.title).toBe('Get test');
+  });
+
+  it('vault_get should return error when not found', async () => {
+    const result = (await findOp('vault_get').handler({ id: 'nonexistent' })) as {
+      error: string;
+    };
+    expect(result.error).toContain('nonexistent');
+  });
+
+  // ─── vault_update ─────────────────────────────────────────────────
+
+  it('vault_update should update title', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vu-1', title: 'Original' })]);
+    const result = (await findOp('vault_update').handler({
+      id: 'vu-1',
+      title: 'Updated',
+    })) as { updated: boolean; entry: IntelligenceEntry };
+    expect(result.updated).toBe(true);
+    expect(result.entry.title).toBe('Updated');
+    // Verify in vault directly
+    expect(runtime.vault.get('vu-1')!.title).toBe('Updated');
+  });
+
+  it('vault_update should update tags', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vu-2', tags: ['old'] })]);
+    const result = (await findOp('vault_update').handler({
+      id: 'vu-2',
+      tags: ['new', 'shiny'],
+    })) as { updated: boolean; entry: IntelligenceEntry };
+    expect(result.entry.tags).toEqual(['new', 'shiny']);
+  });
+
+  it('vault_update should return error when entry not found', async () => {
+    const result = (await findOp('vault_update').handler({
+      id: 'missing',
+      title: 'x',
+    })) as { error: string };
+    expect(result.error).toContain('missing');
+  });
+
+  it('vault_update should return error when no fields provided', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vu-3' })]);
+    const result = (await findOp('vault_update').handler({ id: 'vu-3' })) as { error: string };
+    expect(result.error).toContain('No fields');
+  });
+
+  // ─── vault_remove ─────────────────────────────────────────────────
+
+  it('vault_remove should delete entry', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vr-1' })]);
+    const result = (await findOp('vault_remove').handler({ id: 'vr-1' })) as {
+      removed: boolean;
+      id: string;
+    };
+    expect(result.removed).toBe(true);
+    expect(result.id).toBe('vr-1');
+    expect(runtime.vault.get('vr-1')).toBeNull();
+  });
+
+  it('vault_remove should return removed=false for missing entry', async () => {
+    const result = (await findOp('vault_remove').handler({ id: 'nope' })) as { removed: boolean };
+    expect(result.removed).toBe(false);
+  });
+
+  // ─── vault_bulk_add ───────────────────────────────────────────────
+
+  it('vault_bulk_add should add multiple entries', async () => {
+    const entries = [
+      makeEntry({ id: 'ba-1', title: 'Bulk 1' }),
+      makeEntry({ id: 'ba-2', title: 'Bulk 2' }),
+      makeEntry({ id: 'ba-3', title: 'Bulk 3' }),
+    ];
+    const result = (await findOp('vault_bulk_add').handler({ entries })) as {
+      added: number;
+      total: number;
+    };
+    expect(result.added).toBe(3);
+    expect(result.total).toBe(3);
+    expect(runtime.vault.get('ba-2')!.title).toBe('Bulk 2');
+  });
+
+  it('vault_bulk_add should upsert existing entries', async () => {
+    runtime.vault.seed([makeEntry({ id: 'ba-u1', title: 'Old' })]);
+    const result = (await findOp('vault_bulk_add').handler({
+      entries: [makeEntry({ id: 'ba-u1', title: 'New' })],
+    })) as { added: number; total: number };
+    expect(result.added).toBe(1);
+    expect(result.total).toBe(1); // no new entry, just update
+    expect(runtime.vault.get('ba-u1')!.title).toBe('New');
+  });
+
+  // ─── vault_bulk_remove ────────────────────────────────────────────
+
+  it('vault_bulk_remove should remove multiple entries', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'br-1' }),
+      makeEntry({ id: 'br-2' }),
+      makeEntry({ id: 'br-3' }),
+    ]);
+    const result = (await findOp('vault_bulk_remove').handler({
+      ids: ['br-1', 'br-3'],
+    })) as { removed: number; requested: number; total: number };
+    expect(result.removed).toBe(2);
+    expect(result.requested).toBe(2);
+    expect(result.total).toBe(1); // br-2 remains
+    expect(runtime.vault.get('br-2')).not.toBeNull();
+    expect(runtime.vault.get('br-1')).toBeNull();
+  });
+
+  it('vault_bulk_remove should handle missing IDs gracefully', async () => {
+    runtime.vault.seed([makeEntry({ id: 'br-4' })]);
+    const result = (await findOp('vault_bulk_remove').handler({
+      ids: ['br-4', 'br-missing'],
+    })) as { removed: number; requested: number };
+    expect(result.removed).toBe(1);
+    expect(result.requested).toBe(2);
+  });
+
+  // ─── vault_tags ───────────────────────────────────────────────────
+
+  it('vault_tags should return unique tags with counts', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'vt-1', tags: ['alpha', 'beta'] }),
+      makeEntry({ id: 'vt-2', tags: ['beta', 'gamma'] }),
+      makeEntry({ id: 'vt-3', tags: ['beta'] }),
+    ]);
+    const result = (await findOp('vault_tags').handler({})) as {
+      tags: Array<{ tag: string; count: number }>;
+      count: number;
+    };
+    expect(result.count).toBe(3); // alpha, beta, gamma
+    const beta = result.tags.find((t) => t.tag === 'beta');
+    expect(beta!.count).toBe(3);
+    const alpha = result.tags.find((t) => t.tag === 'alpha');
+    expect(alpha!.count).toBe(1);
+    // beta should be first (highest count)
+    expect(result.tags[0].tag).toBe('beta');
+  });
+
+  it('vault_tags should return empty when vault is empty', async () => {
+    const result = (await findOp('vault_tags').handler({})) as {
+      tags: Array<{ tag: string; count: number }>;
+      count: number;
+    };
+    expect(result.tags).toEqual([]);
+    expect(result.count).toBe(0);
+  });
+
+  // ─── vault_domains ────────────────────────────────────────────────
+
+  it('vault_domains should return domains with counts', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'vd-1', domain: 'security' }),
+      makeEntry({ id: 'vd-2', domain: 'security' }),
+      makeEntry({ id: 'vd-3', domain: 'a11y' }),
+    ]);
+    const result = (await findOp('vault_domains').handler({})) as {
+      domains: Array<{ domain: string; count: number }>;
+      count: number;
+    };
+    expect(result.count).toBe(2);
+    const security = result.domains.find((d) => d.domain === 'security');
+    expect(security!.count).toBe(2);
+    const a11y = result.domains.find((d) => d.domain === 'a11y');
+    expect(a11y!.count).toBe(1);
+  });
+
+  // ─── vault_recent ─────────────────────────────────────────────────
+
+  it('vault_recent should return entries ordered by most recent', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'rec-1', title: 'First' }),
+      makeEntry({ id: 'rec-2', title: 'Second' }),
+    ]);
+    const result = (await findOp('vault_recent').handler({})) as {
+      entries: IntelligenceEntry[];
+      count: number;
+    };
+    expect(result.count).toBe(2);
+    // Both entries should be present
+    expect(result.entries.map((e) => e.id)).toContain('rec-1');
+    expect(result.entries.map((e) => e.id)).toContain('rec-2');
+  });
+
+  it('vault_recent should respect limit', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'rl-1' }),
+      makeEntry({ id: 'rl-2' }),
+      makeEntry({ id: 'rl-3' }),
+    ]);
+    const result = (await findOp('vault_recent').handler({ limit: 2 })) as {
+      entries: IntelligenceEntry[];
+      count: number;
+    };
+    expect(result.count).toBe(2);
+  });
+
+  // ─── vault_import ─────────────────────────────────────────────────
+
+  it('vault_import should import new entries', async () => {
+    const entries = [
+      makeEntry({ id: 'vi-1', title: 'Import 1' }),
+      makeEntry({ id: 'vi-2', title: 'Import 2' }),
+    ];
+    const result = (await findOp('vault_import').handler({ entries })) as {
+      imported: number;
+      newEntries: number;
+      updatedEntries: number;
+      total: number;
+    };
+    expect(result.imported).toBe(2);
+    expect(result.newEntries).toBe(2);
+    expect(result.updatedEntries).toBe(0);
+    expect(result.total).toBe(2);
+  });
+
+  it('vault_import should track updated vs new entries', async () => {
+    runtime.vault.seed([makeEntry({ id: 'vi-3', title: 'Existing' })]);
+    const entries = [
+      makeEntry({ id: 'vi-3', title: 'Updated' }),
+      makeEntry({ id: 'vi-4', title: 'Brand New' }),
+    ];
+    const result = (await findOp('vault_import').handler({ entries })) as {
+      imported: number;
+      newEntries: number;
+      updatedEntries: number;
+      total: number;
+    };
+    expect(result.imported).toBe(2);
+    expect(result.newEntries).toBe(1);
+    expect(result.updatedEntries).toBe(1);
+    expect(result.total).toBe(2);
+  });
+
+  // ─── vault_seed ───────────────────────────────────────────────────
+
+  it('vault_seed should be idempotent', async () => {
+    const entries = [makeEntry({ id: 'vs-1', title: 'Seed' })];
+    const r1 = (await findOp('vault_seed').handler({ entries })) as {
+      seeded: number;
+      total: number;
+    };
+    expect(r1.seeded).toBe(1);
+    expect(r1.total).toBe(1);
+    // Seed again
+    const r2 = (await findOp('vault_seed').handler({ entries })) as {
+      seeded: number;
+      total: number;
+    };
+    expect(r2.seeded).toBe(1);
+    expect(r2.total).toBe(1); // still 1, not 2
+  });
+
+  // ─── vault_backup ─────────────────────────────────────────────────
+
+  it('vault_backup should export all entries', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'vb-1', title: 'Backup 1' }),
+      makeEntry({ id: 'vb-2', title: 'Backup 2' }),
+    ]);
+    const result = (await findOp('vault_backup').handler({})) as {
+      entries: IntelligenceEntry[];
+      exportedAt: number;
+      count: number;
+    };
+    expect(result.count).toBe(2);
+    expect(result.entries.length).toBe(2);
+    expect(result.exportedAt).toBeGreaterThan(0);
+    expect(result.entries.map((e) => e.id).sort()).toEqual(['vb-1', 'vb-2']);
+  });
+
+  it('vault_backup should return empty bundle when vault is empty', async () => {
+    const result = (await findOp('vault_backup').handler({})) as {
+      entries: IntelligenceEntry[];
+      count: number;
+    };
+    expect(result.entries).toEqual([]);
+    expect(result.count).toBe(0);
+  });
+
+  // ─── vault_age_report ─────────────────────────────────────────────
+
+  it('vault_age_report should return age distribution', async () => {
+    runtime.vault.seed([
+      makeEntry({ id: 'va-1' }),
+      makeEntry({ id: 'va-2' }),
+    ]);
+    const result = (await findOp('vault_age_report').handler({})) as {
+      total: number;
+      buckets: Array<{ label: string; count: number; minDays: number; maxDays: number }>;
+      oldestTimestamp: number | null;
+      newestTimestamp: number | null;
+    };
+    expect(result.total).toBe(2);
+    expect(result.buckets.length).toBe(5);
+    // Entries just created should be in the 'today' bucket
+    const today = result.buckets.find((b) => b.label === 'today');
+    expect(today!.count).toBe(2);
+    expect(result.oldestTimestamp).toBeGreaterThan(0);
+    expect(result.newestTimestamp).toBeGreaterThan(0);
+  });
+
+  it('vault_age_report should handle empty vault', async () => {
+    const result = (await findOp('vault_age_report').handler({})) as {
+      total: number;
+      oldestTimestamp: number | null;
+      newestTimestamp: number | null;
+    };
+    expect(result.total).toBe(0);
+    expect(result.oldestTimestamp).toBeNull();
+    expect(result.newestTimestamp).toBeNull();
+  });
+
+  // ─── Auth levels ──────────────────────────────────────────────────
+
+  it('should assign correct auth levels', () => {
+    const readOps = ['vault_get', 'vault_tags', 'vault_domains', 'vault_recent', 'vault_backup', 'vault_age_report'];
+    const writeOps = ['vault_update', 'vault_bulk_add', 'vault_import', 'vault_seed'];
+    const adminOps = ['vault_remove', 'vault_bulk_remove'];
+
+    for (const name of readOps) {
+      expect(findOp(name).auth).toBe('read');
+    }
+    for (const name of writeOps) {
+      expect(findOp(name).auth).toBe('write');
+    }
+    for (const name of adminOps) {
+      expect(findOp(name).auth).toBe('admin');
+    }
+  });
+});

package/src/brain/brain.ts

@@ -17,6 +17,9 @@ import type {
   CaptureResult,
   BrainStats,
   QueryContext,
+  FeedbackInput,
+  FeedbackEntry,
+  FeedbackStats,
 } from './types.js';
 
 // Re-export types for backward compatibility
@@ -268,14 +271,109 @@ export class Brain {
     return result;
   }
 
-  recordFeedback(query: string, entryId: string, action: 'accepted' | 'dismissed'): void {
+  recordFeedback(query: string, entryId: string, action: 'accepted' | 'dismissed'): void;
+  recordFeedback(input: FeedbackInput): FeedbackEntry;
+  recordFeedback(
+    queryOrInput: string | FeedbackInput,
+    entryId?: string,
+    action?: 'accepted' | 'dismissed',
+  ): void | FeedbackEntry {
     const db = this.vault.getDb();
-    db.prepare('INSERT INTO brain_feedback (query, entry_id, action) VALUES (?, ?, ?)').run(
-      query,
-      entryId,
-      action,
+
+    // Normalize to FeedbackInput
+    const input: FeedbackInput =
+      typeof queryOrInput === 'string'
+        ? { query: queryOrInput, entryId: entryId!, action: action! }
+        : queryOrInput;
+
+    db.prepare(
+      `INSERT INTO brain_feedback (query, entry_id, action, source, confidence, duration, context, reason)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      input.query,
+      input.entryId,
+      input.action,
+      input.source ?? 'search',
+      input.confidence ?? 0.6,
+      input.duration ?? null,
+      input.context ?? '{}',
+      input.reason ?? null,
     );
     this.recomputeWeights();
+
+    // Return FeedbackEntry only for the object overload
+    if (typeof queryOrInput !== 'string') {
+      const row = db
+        .prepare(
+          'SELECT * FROM brain_feedback WHERE query = ? AND entry_id = ? ORDER BY id DESC LIMIT 1',
+        )
+        .get(input.query, input.entryId) as {
+        id: number;
+        query: string;
+        entry_id: string;
+        action: string;
+        source: string;
+        confidence: number;
+        duration: number | null;
+        context: string;
+        reason: string | null;
+        created_at: number;
+      };
+      return {
+        id: row.id,
+        query: row.query,
+        entryId: row.entry_id,
+        action: row.action as FeedbackEntry['action'],
+        source: row.source as FeedbackEntry['source'],
+        confidence: row.confidence,
+        duration: row.duration,
+        context: row.context,
+        reason: row.reason,
+        createdAt: row.created_at,
+      };
+    }
+  }
+
+  getFeedbackStats(): FeedbackStats {
+    const db = this.vault.getDb();
+
+    const total = (
+      db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }
+    ).count;
+
+    const byAction: Record<string, number> = {};
+    const actionRows = db
+      .prepare('SELECT action, COUNT(*) as count FROM brain_feedback GROUP BY action')
+      .all() as Array<{ action: string; count: number }>;
+    for (const row of actionRows) {
+      byAction[row.action] = row.count;
+    }
+
+    const bySource: Record<string, number> = {};
+    const sourceRows = db
+      .prepare('SELECT source, COUNT(*) as count FROM brain_feedback GROUP BY source')
+      .all() as Array<{ source: string; count: number }>;
+    for (const row of sourceRows) {
+      bySource[row.source] = row.count;
+    }
+
+    const accepted = byAction['accepted'] ?? 0;
+    const acceptanceRate = total > 0 ? accepted / total : 0;
+
+    const avgConf =
+      (
+        db.prepare('SELECT AVG(confidence) as avg FROM brain_feedback').get() as {
+          avg: number | null;
+        }
+      ).avg ?? 0;
+
+    return {
+      total,
+      byAction,
+      bySource,
+      acceptanceRate,
+      averageConfidence: avgConf,
+    };
   }
 
   async getRelevantPatterns(context: QueryContext): Promise<RankedResult[]> {
@@ -503,8 +601,11 @@ export class Brain {
 
   private recomputeWeights(): void {
     const db = this.vault.getDb();
+    // Exclude 'failed' from weight computation — system errors don't indicate relevance
     const feedbackCount = (
-      db.prepare('SELECT COUNT(*) as count FROM brain_feedback').get() as { count: number }
+      db.prepare("SELECT COUNT(*) as count FROM brain_feedback WHERE action != 'failed'").get() as {
+        count: number;
+      }
     ).count;
     if (feedbackCount < FEEDBACK_THRESHOLD) {
       this.weights = { ...DEFAULT_WEIGHTS };
@@ -516,7 +617,13 @@ export class Brain {
         .prepare("SELECT COUNT(*) as count FROM brain_feedback WHERE action = 'accepted'")
         .get() as { count: number }
     ).count;
-    const acceptRate = feedbackCount > 0 ? accepted / feedbackCount : 0.5;
+    // 'modified' counts as 0.5 positive — user adjusted but didn't dismiss
+    const modified = (
+      db
+        .prepare("SELECT COUNT(*) as count FROM brain_feedback WHERE action = 'modified'")
+        .get() as { count: number }
+    ).count;
+    const acceptRate = feedbackCount > 0 ? (accepted + modified * 0.5) / feedbackCount : 0.5;
 
     const semanticDelta = (acceptRate - 0.5) * WEIGHT_BOUND * 2;