@aria-cli/tools 1.0.9 → 1.0.11

package/tests/executors/memory-real-memoria.integration.test.ts

@@ -1,316 +0,0 @@
-/**
- * CRITICAL Integration Tests: Memory Executors with REAL Memoria
- *
- * Unlike memory.test.ts which uses vi.fn() mocks, these tests wire
- * the memory executors to REAL Memoria instances with in-memory SQLite.
- *
- * This verifies the ACTUAL integration between:
- *   executeRemember() → Memoria.remember() → SQLite storage
- *   executeRecall() → Memoria.recall() → APR/index pipeline
- *   executeForget() → Memoria.deleteMemory() → storage + index cleanup
- *   executeDiscover() → Memoria.recallTools() → knowledge store
- *
- * The existing memory.test.ts validates input validation and error paths;
- * these tests validate the full data round-trip.
- */
-
-import { describe, it, expect, afterEach, vi } from "vitest";
-import type { ToolContext } from "../../src/types.js";
-import {
-  executeRemember,
-  executeRecall,
-  executeForget,
-  executeDiscover,
-} from "../../src/executors/memory.js";
-import { Memoria } from "@aria-cli/memoria";
-
-/**
- * Create a real Memoria instance with in-memory storage for testing
- */
-async function createRealMemoria(): Promise<Memoria> {
-  const memoria = new Memoria({
-    path: ":memory:",
-    embeddings: {
-      provider: "custom" as const,
-      model: "mock-embedding",
-      dimensions: 384,
-    },
-  });
-  await memoria.initialize();
-  return memoria;
-}
-
-/**
- * Create a ToolContext with a real Memoria instance
- */
-function createRealContext(memoria: Memoria): ToolContext {
-  return {
-    workingDir: "/test",
-    env: {},
-    memoria: memoria as any,
-    confirm: async () => true,
-  };
-}
-
-describe("Memory Executors with Real Memoria", () => {
-  let memoria: Memoria;
-
-  afterEach(async () => {
-    if (memoria) {
-      await memoria.close();
-    }
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // REMEMBER → STORAGE
-  // ══════════════════════════════════════════════════════════════
-
-  it("[CRITICAL] executeRemember stores to real Memoria and returns valid ID", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    const result = await executeRemember({ content: "Real Memoria integration test" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.data).toBeDefined();
-    expect((result.data as any).id).toBeTruthy();
-
-    // Verify it's actually in storage
-    const listed = await memoria.list({ limit: 100 });
-    expect(listed).toHaveLength(1);
-    expect(listed[0].content).toBe("Real Memoria integration test");
-  });
-
-  it("[CRITICAL] executeRemember preserves tags and importance in real storage", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    const result = await executeRemember(
-      {
-        content: "Tagged and important memory",
-        tags: ["testing", "integration"],
-        importance: 0.95,
-      },
-      ctx,
-    );
-
-    expect(result.success).toBe(true);
-
-    const listed = await memoria.list({ limit: 100 });
-    expect(listed).toHaveLength(1);
-    expect(listed[0].content).toBe("Tagged and important memory");
-    // Importance should be stored (may be adjusted by classification)
-    expect(typeof listed[0].importance).toBe("number");
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // REMEMBER → RECALL ROUND-TRIP
-  // ══════════════════════════════════════════════════════════════
-
-  it("[CRITICAL] executeRemember then executeRecall returns stored data", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    // Store via executor
-    const rememberResult = await executeRemember(
-      { content: "Round-trip test: TypeScript type inference" },
-      ctx,
-    );
-    expect(rememberResult.success).toBe(true);
-
-    // Recall via executor
-    const recallResult = await executeRecall({ query: "TypeScript type inference" }, ctx);
-    expect(recallResult.success).toBe(true);
-
-    const data = recallResult.data as any;
-    expect(data.count).toBeGreaterThanOrEqual(1);
-    expect(data.memories.some((m: any) => m.content.includes("TypeScript"))).toBe(true);
-  });
-
-  it("should respect recall limit parameter through real Memoria", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    // Store multiple memories
-    for (let i = 0; i < 5; i++) {
-      await executeRemember({ content: `Limit test memory #${i}: programming concept ${i}` }, ctx);
-    }
-
-    // Recall with limit=2
-    const result = await executeRecall({ query: "programming concept", limit: 2 }, ctx);
-    expect(result.success).toBe(true);
-
-    const data = result.data as any;
-    expect(data.count).toBeLessThanOrEqual(2);
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // REMEMBER → FORGET → RECALL
-  // ══════════════════════════════════════════════════════════════
-
-  it("[CRITICAL] executeForget removes memory from real storage", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    // Store
-    const rememberResult = await executeRemember({ content: "Memory to be forgotten" }, ctx);
-    const storedId = (rememberResult.data as any).id;
-
-    // Forget
-    const forgetResult = await executeForget({ id: storedId }, ctx);
-    expect(forgetResult.success).toBe(true);
-    expect((forgetResult.data as any).deleted).toBe(true);
-
-    // Verify gone from storage
-    const listed = await memoria.list({ limit: 100 });
-    expect(listed.every((m) => m.id !== storedId)).toBe(true);
-  });
-
-  it("should handle forget for non-existent ID in real Memoria", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    const result = await executeForget({ id: "non-existent-id-xyz" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("not found");
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // REFLECT WITH REAL KNOWLEDGE STORE
-  // ══════════════════════════════════════════════════════════════
-
-  it("should executeDiscover against real Memoria knowledge store", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    // Store some knowledge first
-    await memoria.rememberTool({
-      name: "vitest-framework",
-      description: "Fast testing framework for Vite projects",
-      confidence: 0.9,
-      tags: ["testing", "vite"],
-    });
-
-    // RecallKnowledge should query real knowledge store
-    const result = await executeDiscover({ topic: "testing framework" }, ctx);
-    expect(result.success).toBe(true);
-
-    const data = result.data as any;
-    expect(typeof data.toolCount).toBe("number");
-    expect(typeof data.skillCount).toBe("number");
-  });
-
-  it("should executeDiscover(kind=skill) against unified skills API", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    // Skill synthesis requires >= 2 sequences with similar tasks (memoria-skills.ts:626).
-    // Run two sequences with the same task pattern to trigger learning.
-    for (let i = 0; i < 2; i++) {
-      memoria.startToolSequence("deploy service to staging");
-      memoria.recordToolUse({
-        tool: "bash",
-        input: { command: "pnpm build" },
-        success: true,
-        timestamp: new Date(),
-      });
-      memoria.recordToolUse({
-        tool: "grep",
-        input: { pattern: "ready", path: "deploy.log" },
-        success: true,
-        timestamp: new Date(),
-      });
-      await memoria.endToolSequence(true);
-    }
-    await memoria.waitForPendingEmbeddings();
-
-    const result = await executeDiscover({ topic: "deploy service to staging", limit: 5 }, ctx);
-    expect(result.success).toBe(true);
-
-    const data = result.data as { skillCount: number; skills: Array<{ id: string }> };
-    expect(data.skillCount).toBeGreaterThan(0);
-    expect(data.skills.length).toBeGreaterThan(0);
-  });
-
-  it("should executeDiscover(default kind) and include auto-learned skills", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    await memoria.rememberTool({
-      name: "kubectl",
-      description: "Kubernetes control CLI",
-      confidence: 0.85,
-      tags: ["k8s"],
-    });
-
-    // Skill synthesis requires >= 2 sequences (memoria-skills.ts:626).
-    for (let i = 0; i < 2; i++) {
-      memoria.startToolSequence("deploy service to staging");
-      memoria.recordToolUse({
-        tool: "bash",
-        input: { command: "pnpm build" },
-        success: true,
-        timestamp: new Date(),
-      });
-      memoria.recordToolUse({
-        tool: "grep",
-        input: { pattern: "ready", path: "deploy.log" },
-        success: true,
-        timestamp: new Date(),
-      });
-      await memoria.endToolSequence(true);
-    }
-    await memoria.waitForPendingEmbeddings();
-
-    const result = await executeDiscover({ topic: "deploy service to staging", limit: 10 }, ctx);
-    expect(result.success).toBe(true);
-
-    const data = result.data as { skillCount: number; skills: Array<{ id: string }> };
-    expect(data.skillCount).toBeGreaterThan(0);
-    expect(data.skills.length).toBeGreaterThan(0);
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // DEDUPLICATION THROUGH EXECUTOR
-  // ══════════════════════════════════════════════════════════════
-
-  it("should deduplicate when same content is remembered twice via executor", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    const first = await executeRemember({ content: "Dedup test via executor" }, ctx);
-    const second = await executeRemember({ content: "Dedup test via executor" }, ctx);
-
-    expect(first.success).toBe(true);
-    expect(second.success).toBe(true);
-
-    // Both should return the same ID
-    expect((first.data as any).id).toBe((second.data as any).id);
-
-    // Only one memory in storage
-    const listed = await memoria.list({ limit: 100 });
-    expect(listed).toHaveLength(1);
-  });
-
-  // ══════════════════════════════════════════════════════════════
-  // CONCURRENT OPERATIONS THROUGH EXECUTOR
-  // ══════════════════════════════════════════════════════════════
-
-  it("should handle concurrent remember calls through executor", async () => {
-    memoria = await createRealMemoria();
-    const ctx = createRealContext(memoria);
-
-    const promises = Array.from({ length: 5 }, (_, i) =>
-      executeRemember({ content: `Concurrent executor test #${i}` }, ctx),
-    );
-
-    const results = await Promise.all(promises);
-    expect(results.every((r) => r.success)).toBe(true);
-
-    const ids = new Set(results.map((r) => (r.data as any).id));
-    expect(ids.size).toBe(5);
-
-    const listed = await memoria.list({ limit: 100 });
-    expect(listed).toHaveLength(5);
-  });
-});