@aria-cli/tools 1.0.9 → 1.0.11

package/tests/executors/recall-tags.test.ts

@@ -1,278 +0,0 @@
-/**
- * H4: Recall Tool Tags Threading
- *
- * Tests that tags are correctly passed through executeRecall() to
- * memoria.recall(). The non-APR fallback path in executeRecall adds
- * extra options (rerank, diversity, expandQuery), so tests use
- * expect.objectContaining() for assertions.
- *
- * Also tests recall-C-2: tags are threaded through the APR path as
- * `networks` in the recallWithAPR options.
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import type { ToolContext } from "../../src/types.js";
-import { executeRecall, type RecallInput } from "../../src/executors/memory.js";
-
-// Helper to create a mock Memoria instance (non-APR fallback path)
-const createMockMemoria = () => ({
-  remember: vi.fn(),
-  recall: vi.fn(),
-  recallTools: vi.fn(),
-  rememberSkill: vi.fn().mockResolvedValue("skill-id"),
-  recallSkills: vi.fn().mockResolvedValue([]),
-  getSkill: vi.fn().mockResolvedValue(null),
-  recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
-  deleteMemory: vi.fn(),
-});
-
-// Helper to create a context with mock Memoria
-const createContext = (memoria?: ReturnType<typeof createMockMemoria>): ToolContext => ({
-  workingDir: "/test/dir",
-  memoria,
-  env: {},
-  confirm: async () => true,
-});
-
-describe("H4: Recall tool tags threading", () => {
-  let mockMemoria: ReturnType<typeof createMockMemoria>;
-  let ctx: ToolContext;
-
-  beforeEach(() => {
-    mockMemoria = createMockMemoria();
-    ctx = createContext(mockMemoria);
-    mockMemoria.recall.mockResolvedValue({ memories: [] });
-  });
-
-  it("should accept tags in RecallInput without type error", () => {
-    const input: RecallInput = {
-      query: "test query",
-      tags: ["important", "work"],
-    } as any;
-
-    expect(input.query).toBe("test query");
-    expect((input as any).tags).toEqual(["important", "work"]);
-  });
-
-  it("should pass tags to memoria.recall() when provided", async () => {
-    const input = {
-      query: "search term",
-      tags: ["important"],
-    };
-
-    await executeRecall(input as any, ctx);
-
-    // The non-APR fallback path adds rerank, diversity, expandQuery
-    expect(mockMemoria.recall).toHaveBeenCalledWith(
-      "search term",
-      expect.objectContaining({
-        limit: 10,
-        tags: ["important"],
-      }),
-    );
-  });
-
-  it("should pass multiple tags to memoria.recall()", async () => {
-    const input = {
-      query: "multi-tag query",
-      tags: ["project-alpha", "urgent", "review"],
-    };
-
-    await executeRecall(input as any, ctx);
-
-    expect(mockMemoria.recall).toHaveBeenCalledWith(
-      "multi-tag query",
-      expect.objectContaining({
-        limit: 10,
-        tags: ["project-alpha", "urgent", "review"],
-      }),
-    );
-  });
-
-  it("should not pass tags when tags array is empty", async () => {
-    const input = {
-      query: "no tags query",
-      tags: [],
-    };
-
-    await executeRecall(input as any, ctx);
-
-    const callArgs = mockMemoria.recall.mock.calls[0][1];
-    expect(callArgs.limit).toBe(10);
-    expect(callArgs).not.toHaveProperty("tags");
-  });
-
-  it("should not pass tags when tags is undefined", async () => {
-    const input = {
-      query: "no tags",
-    };
-
-    await executeRecall(input as any, ctx);
-
-    const callArgs = mockMemoria.recall.mock.calls[0][1];
-    expect(callArgs.limit).toBe(10);
-    expect(callArgs).not.toHaveProperty("tags");
-  });
-
-  it("should pass both tags and custom limit to memoria.recall()", async () => {
-    const input = {
-      query: "limited tagged query",
-      tags: ["critical"],
-      limit: 5,
-    };
-
-    await executeRecall(input as any, ctx);
-
-    expect(mockMemoria.recall).toHaveBeenCalledWith(
-      "limited tagged query",
-      expect.objectContaining({
-        limit: 5,
-        tags: ["critical"],
-      }),
-    );
-  });
-
-  it("should return successful result with tags filtering", async () => {
-    const mockMemories = [{ id: "mem-1", content: "Tagged memory", importance: 0.8 }];
-    mockMemoria.recall.mockResolvedValue({ memories: mockMemories });
-
-    const input = {
-      query: "tagged search",
-      tags: ["important"],
-    };
-
-    const result = await executeRecall(input as any, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.data).toEqual({
-      memories: mockMemories,
-      count: 1,
-    });
-
-    expect(mockMemoria.recall).toHaveBeenCalledWith(
-      "tagged search",
-      expect.objectContaining({ tags: ["important"] }),
-    );
-  });
-});
-
-// ============================================================================
-// recall-C-2: Tags threaded through APR path as networks
-// ============================================================================
-
-// Helper to create a mock Memoria with APR support
-const createMockMemoriaWithAPR = () => ({
-  remember: vi.fn(),
-  recall: vi.fn(),
-  recallTools: vi.fn(),
-  rememberSkill: vi.fn().mockResolvedValue("skill-id"),
-  recallSkills: vi.fn().mockResolvedValue([]),
-  getSkill: vi.fn().mockResolvedValue(null),
-  recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
-  deleteMemory: vi.fn(),
-  recallWithAPR: vi.fn().mockResolvedValue({
-    memories: [],
-    formattedContext: { context: "" },
-    intent: { type: "factual" },
-    sourceStats: { semantic: 0 },
-  }),
-});
-
-const createAPRContext = (memoria?: ReturnType<typeof createMockMemoriaWithAPR>): ToolContext => ({
-  workingDir: "/test/dir",
-  memoria,
-  env: {},
-  confirm: async () => true,
-});
-
-describe("recall-C-2: Tags threaded through APR path as networks", () => {
-  let mockMemoria: ReturnType<typeof createMockMemoriaWithAPR>;
-  let ctx: ToolContext;
-
-  beforeEach(() => {
-    mockMemoria = createMockMemoriaWithAPR();
-    ctx = createAPRContext(mockMemoria);
-  });
-
-  it("should pass tags as networks to recallWithAPR when APR is available", async () => {
-    const input = {
-      query: "search with tags",
-      tags: ["work", "urgent"],
-    };
-
-    await executeRecall(input as any, ctx);
-
-    expect(mockMemoria.recallWithAPR).toHaveBeenCalledWith(
-      "search with tags",
-      expect.objectContaining({
-        limit: 10,
-        networks: ["work", "urgent"],
-      }),
-    );
-    // Should NOT have called fallback recall()
-    expect(mockMemoria.recall).not.toHaveBeenCalled();
-  });
-
-  it("should not include networks when tags is empty on APR path", async () => {
-    const input = {
-      query: "no tags APR query",
-      tags: [],
-    };
-
-    await executeRecall(input as any, ctx);
-
-    const callArgs = mockMemoria.recallWithAPR.mock.calls[0][1];
-    expect(callArgs.limit).toBe(10);
-    expect(callArgs).not.toHaveProperty("networks");
-  });
-
-  it("should not include networks when tags is undefined on APR path", async () => {
-    const input = {
-      query: "undefined tags APR",
-    };
-
-    await executeRecall(input as any, ctx);
-
-    const callArgs = mockMemoria.recallWithAPR.mock.calls[0][1];
-    expect(callArgs.limit).toBe(10);
-    expect(callArgs).not.toHaveProperty("networks");
-  });
-
-  it("should pass networks and custom limit to recallWithAPR", async () => {
-    const input = {
-      query: "limited APR query",
-      tags: ["critical"],
-      limit: 3,
-    };
-
-    await executeRecall(input as any, ctx);
-
-    expect(mockMemoria.recallWithAPR).toHaveBeenCalledWith(
-      "limited APR query",
-      expect.objectContaining({
-        limit: 3,
-        networks: ["critical"],
-      }),
-    );
-  });
-
-  it("should return APR metadata (formattedContext, intent, sourceStats) in output", async () => {
-    mockMemoria.recallWithAPR.mockResolvedValue({
-      memories: [{ id: "m-1", content: "hello" }],
-      formattedContext: { context: "Relevant context" },
-      intent: { type: "factual" },
-      sourceStats: { semantic: 1, temporal: 0 },
-    });
-
-    const input = { query: "test APR output" };
-    const result = await executeRecall(input as any, ctx);
-
-    expect(result.success).toBe(true);
-    const data = result.data as any;
-    expect(data.memories).toHaveLength(1);
-    expect(data.count).toBe(1);
-    expect(data.formattedContext).toBe("Relevant context");
-    expect(data.intent).toBe("factual");
-    expect(data.sourceStats).toEqual({ semantic: 1, temporal: 0 });
-  });
-});

package/tests/executors/remember-null-safety.contract.test.ts

@@ -1,41 +0,0 @@
-/**
- * Remember Null Safety Contract Tests
- *
- * Verifies that executeRemember() handles null return from degraded Memoria.
- * Tests the ACTUAL BUG: memory.ts:132 does result.id without null guard.
- * ALL TESTS MUST FAIL against current code.
- */
-import { describe, it, expect } from "vitest";
-import { executeRemember } from "../../src/executors/memory.js";
-
-describe("executeRemember null safety", () => {
-  it("should return failure when memoria.remember() returns null", async () => {
-    const degradedMemoria = {
-      remember: async () => null,
-      recall: async () => [],
-      deleteMemory: async () => false,
-    };
-    const ctx = { memoria: degradedMemoria } as any;
-    const input = { content: "test content" };
-    const result = await executeRemember(input, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toBeDefined();
-  });
-
-  it("should return success when memoria.remember() returns a Memory", async () => {
-    const mockMemory = {
-      id: "mem-123",
-      content: "test content",
-      createdAt: new Date(),
-    };
-    const workingMemoria = {
-      remember: async () => mockMemory,
-      recall: async () => [],
-      deleteMemory: async () => false,
-    };
-    const ctx = { memoria: workingMemoria } as any;
-    const input = { content: "test content" };
-    const result = await executeRemember(input, ctx);
-    expect(result.success).toBe(true);
-  });
-});

package/tests/executors/restart.test.ts

@@ -1,67 +0,0 @@
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockSpawn } = vi.hoisted(() => ({
-  mockSpawn: vi.fn(),
-}));
-
-vi.mock("node:child_process", () => ({
-  spawn: mockSpawn,
-}));
-
-import type { ToolContext } from "../../src/types.js";
-import { executeRestart } from "../../src/executors/restart.js";
-import { NO_RELAUNCH_ENV, RELAUNCH_EXIT_CODE } from "@aria-cli/types";
-
-function createContext(workingDir: string): ToolContext {
-  return {
-    workingDir,
-    env: {},
-    confirm: async () => true,
-  };
-}
-
-describe("executeRestart", () => {
-  let originalNoRelaunch: string | undefined;
-
-  beforeEach(() => {
-    originalNoRelaunch = process.env[NO_RELAUNCH_ENV];
-    mockSpawn.mockReset();
-    mockSpawn.mockReturnValue({ unref: vi.fn(), on: vi.fn() });
-    delete process.env[NO_RELAUNCH_ENV];
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    if (originalNoRelaunch === undefined) delete process.env[NO_RELAUNCH_ENV];
-    else process.env[NO_RELAUNCH_ENV] = originalNoRelaunch;
-  });
-
-  it("supervised path: exits with RELAUNCH_EXIT_CODE when supervisor present", async () => {
-    process.env[NO_RELAUNCH_ENV] = "true";
-    const workingDir = mkdtempSync(join(tmpdir(), "aria-restart-sup-"));
-    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((
-      code?: string | number | null,
-    ) => {
-      throw new Error(`exit:${String(code)}`);
-    }) as never);
-
-    await expect(
-      executeRestart({ reason: "supervised test" }, createContext(workingDir)),
-    ).rejects.toThrow(`exit:${RELAUNCH_EXIT_CODE}`);
-
-    expect(exitSpy).toHaveBeenCalledWith(RELAUNCH_EXIT_CODE);
-  });
-
-  it("daemon path: sends SIGINT for graceful restart when not supervised", async () => {
-    const workingDir = mkdtempSync(join(tmpdir(), "aria-restart-daemon-"));
-    const killSpy = vi.spyOn(process, "kill").mockImplementation((() => {}) as never);
-
-    const result = await executeRestart({ reason: "daemon test" }, createContext(workingDir));
-
-    expect(result.success).toBe(true);
-    expect(killSpy).toHaveBeenCalledWith(expect.any(Number), "SIGINT");
-  });
-});