@soleri/core 2.1.0 → 2.5.0

package/src/__tests__/memory-cross-project-ops.test.ts

@@ -0,0 +1,248 @@
+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 { createCoreOps } from '../runtime/core-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('Memory Cross-Project Ops', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), 'cross-project-test-' + Date.now());
+    mkdirSync(tempDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'test-cross-project',
+      vaultPath: ':memory:',
+      plansPath: join(tempDir, 'plans.json'),
+    });
+    ops = createCoreOps(runtime);
+  });
+
+  afterEach(() => {
+    runtime.close();
+    rmSync(tempDir, { 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;
+  }
+
+  describe('memory_promote_to_global', () => {
+    it('should add _global tag to a vault entry', async () => {
+      // Add an entry first
+      runtime.vault.add({
+        id: 'test-entry-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Test Pattern',
+        severity: 'suggestion',
+        description: 'A test pattern for cross-project sharing',
+        tags: ['test'],
+      });
+
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'test-entry-1',
+      })) as { promoted: boolean; tags: string[] };
+
+      expect(result.promoted).toBe(true);
+      expect(result.tags).toContain('_global');
+      expect(result.tags).toContain('test');
+
+      // Verify the entry actually has the tag
+      const entry = runtime.vault.get('test-entry-1');
+      expect(entry!.tags).toContain('_global');
+    });
+
+    it('should return error for non-existent entry', async () => {
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'nonexistent',
+      })) as { promoted: boolean; error: string };
+
+      expect(result.promoted).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+
+    it('should not duplicate _global tag', async () => {
+      runtime.vault.add({
+        id: 'test-entry-2',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Already Global',
+        severity: 'suggestion',
+        description: 'Already promoted',
+        tags: ['_global'],
+      });
+
+      const result = (await findOp('memory_promote_to_global').handler({
+        entryId: 'test-entry-2',
+      })) as { promoted: boolean; message: string };
+
+      expect(result.promoted).toBe(false);
+      expect(result.message).toContain('already promoted');
+    });
+  });
+
+  describe('memory_configure', () => {
+    it('should configure cross-project settings', async () => {
+      // Register a project first
+      runtime.projectRegistry.register('/test/project-a', 'project-a');
+
+      const result = (await findOp('memory_configure').handler({
+        projectPath: '/test/project-a',
+        crossProjectEnabled: true,
+        extraPaths: ['/test/shared'],
+      })) as { configured: boolean; memoryConfig: Record<string, unknown> };
+
+      expect(result.configured).toBe(true);
+      expect(result.memoryConfig.crossProjectEnabled).toBe(true);
+      expect(result.memoryConfig.extraPaths).toEqual(['/test/shared']);
+    });
+
+    it('should return error for unregistered project', async () => {
+      const result = (await findOp('memory_configure').handler({
+        projectPath: '/unregistered/path',
+        crossProjectEnabled: true,
+      })) as { configured: boolean; error: string };
+
+      expect(result.configured).toBe(false);
+      expect(result.error).toContain('not registered');
+    });
+
+    it('should preserve existing metadata when updating config', async () => {
+      runtime.projectRegistry.register('/test/project-b', 'project-b', { custom: 'value' });
+
+      await findOp('memory_configure').handler({
+        projectPath: '/test/project-b',
+        crossProjectEnabled: false,
+      });
+
+      const project = runtime.projectRegistry.getByPath('/test/project-b');
+      expect(project!.metadata.custom).toBe('value');
+      expect((project!.metadata.memoryConfig as Record<string, unknown>).crossProjectEnabled).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('memory_cross_project_search', () => {
+    it('should search current project memories', async () => {
+      runtime.projectRegistry.register('/test/current', 'current');
+
+      // Capture a memory
+      runtime.vault.captureMemory({
+        projectPath: '/test/current',
+        type: 'lesson',
+        context: 'testing',
+        summary: 'Always use vitest for TypeScript projects',
+        topics: ['testing', 'vitest'],
+        filesModified: [],
+        toolsUsed: [],
+      });
+
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'vitest',
+        projectPath: '/test/current',
+      })) as { memories: Array<{ weight: number; source: string }>; totalResults: number };
+
+      expect(result.memories.length).toBeGreaterThanOrEqual(1);
+      expect(result.memories[0].weight).toBe(1.0);
+      expect(result.memories[0].source).toBe('current');
+    });
+
+    it('should include global entries in results', async () => {
+      runtime.projectRegistry.register('/test/current', 'current');
+
+      // Add a global entry
+      runtime.vault.add({
+        id: 'global-pattern',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Global Testing Pattern',
+        severity: 'suggestion',
+        description: 'A globally promoted testing pattern for vitest',
+        tags: ['_global', 'testing'],
+      });
+
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'testing',
+        projectPath: '/test/current',
+      })) as { globalEntries: Array<{ weight: number; source: string }> };
+
+      expect(result.globalEntries.length).toBeGreaterThanOrEqual(1);
+      expect(result.globalEntries[0].weight).toBe(0.9);
+      expect(result.globalEntries[0].source).toBe('global');
+    });
+
+    it('should search linked project memories', async () => {
+      const projA = runtime.projectRegistry.register('/test/project-a', 'project-a');
+      const projB = runtime.projectRegistry.register('/test/project-b', 'project-b');
+      runtime.projectRegistry.link(projA.id, projB.id, 'related');
+
+      // Configure cross-project for project A
+      await findOp('memory_configure').handler({
+        projectPath: '/test/project-a',
+        crossProjectEnabled: true,
+      });
+
+      // Capture memory in project B
+      runtime.vault.captureMemory({
+        projectPath: '/test/project-b',
+        type: 'lesson',
+        context: 'architecture',
+        summary: 'Use facade pattern for clean separation',
+        topics: ['architecture', 'facade'],
+        filesModified: [],
+        toolsUsed: [],
+      });
+
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'facade',
+        projectPath: '/test/project-a',
+      })) as {
+        linkedMemories: Array<{ weight: number; source: string; linkedProject: string }>;
+      };
+
+      expect(result.linkedMemories.length).toBeGreaterThanOrEqual(1);
+      expect(result.linkedMemories[0].weight).toBe(0.8);
+      expect(result.linkedMemories[0].source).toBe('linked');
+      expect(result.linkedMemories[0].linkedProject).toBe('/test/project-b');
+    });
+
+    it('should respect crossProjectEnabled=false', async () => {
+      const projA = runtime.projectRegistry.register('/test/disabled-a', 'disabled-a');
+      const projB = runtime.projectRegistry.register('/test/disabled-b', 'disabled-b');
+      runtime.projectRegistry.link(projA.id, projB.id, 'related');
+
+      // Explicitly disable cross-project
+      await findOp('memory_configure').handler({
+        projectPath: '/test/disabled-a',
+        crossProjectEnabled: false,
+      });
+
+      // Capture memory in project B
+      runtime.vault.captureMemory({
+        projectPath: '/test/disabled-b',
+        type: 'lesson',
+        context: 'testing',
+        summary: 'This should not appear in cross-project search',
+        topics: ['hidden'],
+        filesModified: [],
+        toolsUsed: [],
+      });
+
+      const result = (await findOp('memory_cross_project_search').handler({
+        query: 'hidden',
+        projectPath: '/test/disabled-a',
+      })) as { linkedMemories: unknown[] };
+
+      expect(result.linkedMemories).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,352 @@
+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 { createMemoryExtraOps } from '../runtime/memory-extra-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createMemoryExtraOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+  let plannerDir: string;
+
+  beforeEach(() => {
+    plannerDir = join(tmpdir(), 'memory-extra-ops-test-' + Date.now());
+    mkdirSync(plannerDir, { recursive: true });
+    runtime = createAgentRuntime({
+      agentId: 'test-memory-extra',
+      vaultPath: ':memory:',
+      plansPath: join(plannerDir, 'plans.json'),
+    });
+    ops = createMemoryExtraOps(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;
+  }
+
+  /** Helper to create a test memory and return its ID */
+  function captureTestMemory(overrides?: {
+    projectPath?: string;
+    type?: 'session' | 'lesson' | 'preference';
+    summary?: string;
+    topics?: string[];
+  }) {
+    return runtime.vault.captureMemory({
+      projectPath: overrides?.projectPath ?? '/test/project',
+      type: overrides?.type ?? 'lesson',
+      context: 'Test context',
+      summary: overrides?.summary ?? 'Test memory summary',
+      topics: overrides?.topics ?? ['testing'],
+      filesModified: ['file.ts'],
+      toolsUsed: ['tool1'],
+    });
+  }
+
+  it('should return 8 ops', () => {
+    expect(ops.length).toBe(8);
+  });
+
+  it('should have all expected op names', () => {
+    const names = ops.map((o) => o.name);
+    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');
+  });
+
+  // ─── memory_delete ──────────────────────────────────────────────
+
+  it('memory_delete should delete an existing memory', async () => {
+    const mem = captureTestMemory();
+    const result = (await findOp('memory_delete').handler({ memoryId: mem.id })) as {
+      deleted: boolean;
+      memoryId: string;
+    };
+    expect(result.deleted).toBe(true);
+    expect(result.memoryId).toBe(mem.id);
+    expect(runtime.vault.getMemory(mem.id)).toBeNull();
+  });
+
+  it('memory_delete should return error for non-existent memory', async () => {
+    const result = (await findOp('memory_delete').handler({ memoryId: 'non-existent' })) as {
+      deleted: boolean;
+      error: string;
+    };
+    expect(result.deleted).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  // ─── memory_stats ──────────────────────────────────────────────
+
+  it('memory_stats should return detailed statistics', async () => {
+    captureTestMemory({ type: 'lesson', projectPath: '/proj-a' });
+    captureTestMemory({ type: 'session', projectPath: '/proj-a' });
+    captureTestMemory({ type: 'lesson', projectPath: '/proj-b' });
+
+    const result = (await findOp('memory_stats').handler({})) as {
+      total: number;
+      byType: Record<string, number>;
+      byProject: Record<string, number>;
+      oldest: number | null;
+      newest: number | null;
+      archivedCount: number;
+    };
+    expect(result.total).toBe(3);
+    expect(result.byType['lesson']).toBe(2);
+    expect(result.byType['session']).toBe(1);
+    expect(result.byProject['/proj-a']).toBe(2);
+    expect(result.byProject['/proj-b']).toBe(1);
+    expect(result.oldest).toBeTypeOf('number');
+    expect(result.newest).toBeTypeOf('number');
+    expect(result.archivedCount).toBe(0);
+  });
+
+  it('memory_stats should filter by projectPath', async () => {
+    captureTestMemory({ projectPath: '/proj-a' });
+    captureTestMemory({ projectPath: '/proj-b' });
+
+    const result = (await findOp('memory_stats').handler({ projectPath: '/proj-a' })) as {
+      total: number;
+    };
+    expect(result.total).toBe(1);
+  });
+
+  // ─── memory_export ──────────────────────────────────────────────
+
+  it('memory_export should export all memories', async () => {
+    captureTestMemory({ summary: 'Export test 1' });
+    captureTestMemory({ summary: 'Export test 2' });
+
+    const result = (await findOp('memory_export').handler({})) as {
+      exported: boolean;
+      count: number;
+      memories: unknown[];
+    };
+    expect(result.exported).toBe(true);
+    expect(result.count).toBe(2);
+    expect(result.memories.length).toBe(2);
+  });
+
+  it('memory_export should filter by project', async () => {
+    captureTestMemory({ projectPath: '/proj-a', summary: 'A' });
+    captureTestMemory({ projectPath: '/proj-b', summary: 'B' });
+
+    const result = (await findOp('memory_export').handler({ projectPath: '/proj-a' })) as {
+      count: number;
+    };
+    expect(result.count).toBe(1);
+  });
+
+  it('memory_export should filter by type', async () => {
+    captureTestMemory({ type: 'lesson', summary: 'Lesson' });
+    captureTestMemory({ type: 'session', summary: 'Session' });
+
+    const result = (await findOp('memory_export').handler({ type: 'lesson' })) as {
+      count: number;
+    };
+    expect(result.count).toBe(1);
+  });
+
+  // ─── memory_import ──────────────────────────────────────────────
+
+  it('memory_import should import new memories', async () => {
+    const result = (await findOp('memory_import').handler({
+      memories: [
+        {
+          id: 'import-1',
+          projectPath: '/imported',
+          type: 'lesson',
+          context: 'Imported context',
+          summary: 'Imported memory',
+          topics: ['imported'],
+          filesModified: [],
+          toolsUsed: [],
+          createdAt: Math.floor(Date.now() / 1000),
+          archivedAt: null,
+        },
+      ],
+    })) as { imported: number; skipped: number; total: number };
+    expect(result.imported).toBe(1);
+    expect(result.skipped).toBe(0);
+    expect(result.total).toBe(1);
+
+    const mem = runtime.vault.getMemory('import-1');
+    expect(mem).not.toBeNull();
+    expect(mem!.summary).toBe('Imported memory');
+  });
+
+  it('memory_import should skip duplicates', async () => {
+    const mem = captureTestMemory();
+
+    const result = (await findOp('memory_import').handler({
+      memories: [
+        {
+          id: mem.id,
+          projectPath: mem.projectPath,
+          type: mem.type,
+          context: mem.context,
+          summary: mem.summary,
+          topics: mem.topics,
+          filesModified: mem.filesModified,
+          toolsUsed: mem.toolsUsed,
+          createdAt: mem.createdAt,
+          archivedAt: null,
+        },
+      ],
+    })) as { imported: number; skipped: number };
+    expect(result.imported).toBe(0);
+    expect(result.skipped).toBe(1);
+  });
+
+  // ─── memory_prune ──────────────────────────────────────────────
+
+  it('memory_prune should delete old memories', async () => {
+    // Insert a memory with an old timestamp directly via db
+    const db = runtime.vault.getDb();
+    const oldTimestamp = Math.floor(Date.now() / 1000) - 100 * 86400; // 100 days ago
+    db.prepare(
+      `INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used, created_at)
+       VALUES ('old-mem', '/test', 'lesson', 'old', 'Old memory', '[]', '[]', '[]', ?)`,
+    ).run(oldTimestamp);
+
+    // Also capture a fresh memory
+    captureTestMemory({ summary: 'Fresh memory' });
+
+    const result = (await findOp('memory_prune').handler({ olderThanDays: 30 })) as {
+      pruned: number;
+      olderThanDays: number;
+    };
+    expect(result.pruned).toBe(1);
+    expect(result.olderThanDays).toBe(30);
+
+    // Fresh memory should remain
+    const remaining = runtime.vault.listMemories({});
+    expect(remaining.length).toBe(1);
+    expect(remaining[0].summary).toBe('Fresh memory');
+  });
+
+  it('memory_prune should not prune recent memories', async () => {
+    captureTestMemory({ summary: 'Recent' });
+
+    const result = (await findOp('memory_prune').handler({ olderThanDays: 1 })) as {
+      pruned: number;
+    };
+    expect(result.pruned).toBe(0);
+  });
+
+  // ─── memory_deduplicate ─────────────────────────────────────────
+
+  it('memory_deduplicate should remove duplicates', async () => {
+    captureTestMemory({ summary: 'Duplicate summary', projectPath: '/proj', type: 'lesson' });
+    captureTestMemory({ summary: 'Duplicate summary', projectPath: '/proj', type: 'lesson' });
+    captureTestMemory({ summary: 'Unique summary', projectPath: '/proj', type: 'lesson' });
+
+    const result = (await findOp('memory_deduplicate').handler({})) as {
+      removed: number;
+      groups: Array<{ kept: string; removed: string[] }>;
+    };
+    expect(result.removed).toBe(1);
+    expect(result.groups.length).toBe(1);
+    expect(result.groups[0].removed.length).toBe(1);
+
+    const remaining = runtime.vault.listMemories({});
+    expect(remaining.length).toBe(2);
+  });
+
+  it('memory_deduplicate should return 0 when no duplicates', async () => {
+    captureTestMemory({ summary: 'Unique 1' });
+    captureTestMemory({ summary: 'Unique 2' });
+
+    const result = (await findOp('memory_deduplicate').handler({})) as { removed: number };
+    expect(result.removed).toBe(0);
+  });
+
+  // ─── memory_topics ──────────────────────────────────────────────
+
+  it('memory_topics should list unique topics with counts', async () => {
+    captureTestMemory({ topics: ['react', 'testing'] });
+    captureTestMemory({ topics: ['react', 'hooks'] });
+    captureTestMemory({ topics: ['testing'] });
+
+    const result = (await findOp('memory_topics').handler({})) as {
+      count: number;
+      topics: Array<{ topic: string; count: number }>;
+    };
+    expect(result.count).toBe(3); // react, testing, hooks
+    // Sorted by frequency descending
+    expect(result.topics[0].topic).toBe('react');
+    expect(result.topics[0].count).toBe(2);
+    expect(result.topics[1].topic).toBe('testing');
+    expect(result.topics[1].count).toBe(2);
+    expect(result.topics[2].topic).toBe('hooks');
+    expect(result.topics[2].count).toBe(1);
+  });
+
+  it('memory_topics should return empty when no memories', async () => {
+    const result = (await findOp('memory_topics').handler({})) as { count: number };
+    expect(result.count).toBe(0);
+  });
+
+  // ─── memory_by_project ──────────────────────────────────────────
+
+  it('memory_by_project should group memories by project', async () => {
+    captureTestMemory({ projectPath: '/proj-a', summary: 'A1' });
+    captureTestMemory({ projectPath: '/proj-a', summary: 'A2' });
+    captureTestMemory({ projectPath: '/proj-b', summary: 'B1' });
+
+    const result = (await findOp('memory_by_project').handler({})) as {
+      count: number;
+      projects: Array<{
+        project: string;
+        count: number;
+        memories: Array<{ summary: string }>;
+      }>;
+    };
+    expect(result.count).toBe(2);
+    const projA = result.projects.find((p) => p.project === '/proj-a');
+    const projB = result.projects.find((p) => p.project === '/proj-b');
+    expect(projA).toBeDefined();
+    expect(projA!.count).toBe(2);
+    expect(projA!.memories.length).toBe(2);
+    expect(projB).toBeDefined();
+    expect(projB!.count).toBe(1);
+  });
+
+  it('memory_by_project should return counts only when includeMemories=false', async () => {
+    captureTestMemory({ projectPath: '/proj-a', summary: 'A1' });
+
+    const result = (await findOp('memory_by_project').handler({ includeMemories: false })) as {
+      count: number;
+      projects: Array<{ project: string; count: number; memories?: unknown }>;
+    };
+    expect(result.count).toBe(1);
+    expect(result.projects[0].memories).toBeUndefined();
+  });
+
+  // ─── Auth levels ────────────────────────────────────────────────
+
+  it('should have correct auth levels', () => {
+    expect(findOp('memory_delete').auth).toBe('write');
+    expect(findOp('memory_stats').auth).toBe('read');
+    expect(findOp('memory_export').auth).toBe('read');
+    expect(findOp('memory_import').auth).toBe('write');
+    expect(findOp('memory_prune').auth).toBe('admin');
+    expect(findOp('memory_deduplicate').auth).toBe('admin');
+    expect(findOp('memory_topics').auth).toBe('read');
+    expect(findOp('memory_by_project').auth).toBe('read');
+  });
+});