@aria-cli/tools 1.0.0

package/tests/executors/memory-bugfixes.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Memory Executor Bug Fix Tests
+ *
+ * Tests for three specific bug fixes:
+ * - C-1: executeRemember crashes on degraded Memoria result
+ * - F-16: executeRecall discards APR formattedContext/intent/sourceStats
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import type { ToolContext } from "../../src/types.js";
+import { executeRemember, executeRecall, type RecallOutput } from "../../src/executors/memory.js";
+
+// Helper to create a mock Memoria with core methods
+function createMockMemoria(overrides: Record<string, unknown> = {}) {
+  return {
+    remember: vi.fn(),
+    recall: vi.fn(),
+    deleteMemory: vi.fn(),
+    ...overrides,
+  };
+}
+
+// Helper to create a ToolContext with optional memoria
+function createContext(memoria?: ReturnType<typeof createMockMemoria>): ToolContext {
+  return {
+    workingDir: "/test/dir",
+    env: {},
+    confirm: async () => true,
+    memoria: memoria as any,
+  };
+}
+
+// ============================================================================
+// C-1: executeRemember handles degraded Memoria result
+// ============================================================================
+
+describe("C-1: executeRemember degraded result handling", () => {
+  it("should return failure when remember() returns {degraded: true, data: null}", async () => {
+    const degradedResult = { degraded: true, data: null };
+    const mockMemoria = createMockMemoria();
+    mockMemoria.remember.mockResolvedValue(degradedResult);
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRemember({ content: "test content" }, ctx);
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("degraded");
+  });
+
+  it("should return failure when remember() returns null (closed)", async () => {
+    const mockMemoria = createMockMemoria();
+    mockMemoria.remember.mockResolvedValue(null);
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRemember({ content: "test content" }, ctx);
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("degraded");
+  });
+
+  it("should return failure when remember() returns object without id", async () => {
+    const noIdResult = { content: "stored", importance: 0.5 };
+    const mockMemoria = createMockMemoria();
+    mockMemoria.remember.mockResolvedValue(noIdResult);
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRemember({ content: "test content" }, ctx);
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("degraded");
+  });
+
+  it("should return success when remember() returns a proper Memory with id", async () => {
+    const validResult = { id: "mem-abc-123", content: "test", importance: 0.8 };
+    const mockMemoria = createMockMemoria();
+    mockMemoria.remember.mockResolvedValue(validResult);
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRemember({ content: "test content" }, ctx);
+
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual({ id: "mem-abc-123" });
+  });
+
+  it("should return failure when remember() returns {degraded: true} with extra fields", async () => {
+    const degradedResult = {
+      degraded: true,
+      data: null,
+      reason: "storage full",
+      timestamp: Date.now(),
+    };
+    const mockMemoria = createMockMemoria();
+    mockMemoria.remember.mockResolvedValue(degradedResult);
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRemember({ content: "test content" }, ctx);
+
+    expect(result.success).toBe(false);
+  });
+});
+
+// ============================================================================
+// F-16: executeRecall captures APR metadata
+// ============================================================================
+
+describe("F-16: executeRecall APR metadata forwarding", () => {
+  it("should include formattedContext from recallWithAPR in result data", async () => {
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: [{ id: "m-1", content: "hello" }],
+        formattedContext: { context: "Relevant memories:\n- hello" },
+        intent: { type: "factual", confidence: 0.9 },
+        sourceStats: { semantic: 1, temporal: 0, entity: 0, keyword: 0 },
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "test query" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.formattedContext).toBe("Relevant memories:\n- hello");
+  });
+
+  it("should include intent type from recallWithAPR in result data", async () => {
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: [{ id: "m-1", content: "hello" }],
+        formattedContext: { context: "context" },
+        intent: { type: "temporal", confidence: 0.85 },
+        sourceStats: { semantic: 0, temporal: 1, entity: 0, keyword: 0 },
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "what happened yesterday" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.intent).toBe("temporal");
+  });
+
+  it("should include sourceStats from recallWithAPR in result data", async () => {
+    const expectedStats = { semantic: 3, temporal: 2, entity: 1, keyword: 0 };
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: [{ id: "m-1" }, { id: "m-2" }, { id: "m-3" }],
+        formattedContext: { context: "ctx" },
+        intent: { type: "factual" },
+        sourceStats: expectedStats,
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "test" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.sourceStats).toEqual(expectedStats);
+  });
+
+  it("should omit APR fields when recallWithAPR is not available", async () => {
+    const mockMemoria = createMockMemoria();
+    mockMemoria.recall.mockResolvedValue({ memories: [{ id: "m-1" }] });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "test" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.memories).toHaveLength(1);
+    expect(data.count).toBe(1);
+    expect(data.formattedContext).toBeUndefined();
+    expect(data.intent).toBeUndefined();
+    expect(data.sourceStats).toBeUndefined();
+  });
+
+  it("should handle recallWithAPR returning empty memories with metadata", async () => {
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: [],
+        formattedContext: { context: "No relevant memories found." },
+        intent: { type: "factual", confidence: 0.6 },
+        sourceStats: { semantic: 0, temporal: 0, entity: 0, keyword: 0 },
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "obscure topic" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.memories).toHaveLength(0);
+    expect(data.count).toBe(0);
+    expect(data.formattedContext).toBe("No relevant memories found.");
+    expect(data.intent).toBe("factual");
+  });
+
+  it("should still return memories alongside APR metadata", async () => {
+    const mockMemories = [
+      { id: "m-1", content: "first" },
+      { id: "m-2", content: "second" },
+    ];
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: mockMemories,
+        formattedContext: { context: "Two relevant memories" },
+        intent: { type: "entity", confidence: 0.95 },
+        sourceStats: { semantic: 1, temporal: 0, entity: 1, keyword: 0 },
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "test" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.memories).toEqual(mockMemories);
+    expect(data.count).toBe(2);
+    expect(data.formattedContext).toBe("Two relevant memories");
+  });
+
+  it("should pass limit to recallWithAPR", async () => {
+    const recallWithAPRMock = vi.fn().mockResolvedValue({
+      memories: [],
+      formattedContext: { context: "" },
+      intent: { type: "factual" },
+      sourceStats: {},
+    });
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: recallWithAPRMock,
+    });
+    const ctx = createContext(mockMemoria);
+
+    await executeRecall({ query: "test", limit: 5 }, ctx);
+
+    expect(recallWithAPRMock).toHaveBeenCalledWith("test", { limit: 5 });
+  });
+
+  it("should gracefully handle recallWithAPR returning partial metadata", async () => {
+    const mockMemoria = createMockMemoria({
+      recallWithAPR: vi.fn().mockResolvedValue({
+        memories: [{ id: "m-1" }],
+        formattedContext: { context: "partial" },
+      }),
+    });
+    const ctx = createContext(mockMemoria);
+
+    const result = await executeRecall({ query: "test" }, ctx);
+
+    expect(result.success).toBe(true);
+    const data = result.data as RecallOutput;
+    expect(data.formattedContext).toBe("partial");
+    expect(data.intent).toBeUndefined();
+    expect(data.sourceStats).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,316 @@
+/**
+ * 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/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);
+  });
+});