@aria-cli/tools 1.0.8 → 1.0.10

package/tests/executors/frg-freshness.test.ts

@@ -1,136 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import {
-  DEFAULT_BACKGROUND_FRG_FLUSH_DELAY_MS,
-  MAX_PENDING_MUTATIONS_BEFORE_SYNC_FLUSH,
-  clearPendingFrgMutations,
-  ensureFrgRepoStateLoaded,
-  getFrgFreshnessSnapshot,
-  getGitDirtyStatus,
-  getPendingFrgMutations,
-  recordFrgMutation,
-  scheduleBackgroundFrgFlush,
-  searchPendingFrgMutations,
-  shouldForceSynchronousFrgFlush,
-} from "../../src/executors/frg-freshness.js";
-
-describe("frg freshness manager", () => {
-  let repoDir: string;
-  let filePath: string;
-
-  beforeEach(async () => {
-    repoDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-frg-freshness-"));
-    await fs.mkdir(path.join(repoDir, ".git"));
-    await fs.writeFile(path.join(repoDir, "a.ts"), "export const a = 1;\n", "utf8");
-    filePath = path.join(repoDir, "a.ts");
-    clearPendingFrgMutations(repoDir);
-  });
-
-  it("records write mutations in sequence order", () => {
-    recordFrgMutation(filePath, "write");
-    recordFrgMutation(filePath, "write");
-
-    const pending = getPendingFrgMutations(repoDir);
-    expect(pending).toHaveLength(1);
-    expect(pending[0]?.operation).toBe("write");
-    expect(pending[0]?.path).toBe(path.resolve(filePath));
-  });
-
-  it("tracks delete operations", () => {
-    recordFrgMutation(filePath, "delete");
-    const pending = getPendingFrgMutations(repoDir);
-    expect(pending).toHaveLength(1);
-    expect(pending[0]?.operation).toBe("delete");
-  });
-
-  it("searches pending session mutations directly", async () => {
-    const updatedContent = 'export const token = "abc123";\nexport const Beta = 2;\n';
-    await fs.writeFile(filePath, updatedContent, "utf8");
-    recordFrgMutation(filePath, "write", updatedContent);
-
-    const result = await searchPendingFrgMutations(repoDir, {
-      pattern: "abc123",
-      literal: true,
-    });
-    expect(result?.mode).toBe("matches");
-    expect(result && result.mode === "matches" ? result.matches?.length : 0).toBeGreaterThan(0);
-
-    const filesOnly = await searchPendingFrgMutations(repoDir, {
-      pattern: "token",
-      filesOnly: true,
-    });
-    expect(filesOnly?.mode).toBe("files");
-    expect(filesOnly && filesOnly.mode === "files" ? filesOnly.files : []).toContain("a.ts");
-
-    const count = await searchPendingFrgMutations(repoDir, {
-      pattern: "export",
-      count: true,
-    });
-    expect(count?.mode).toBe("counts");
-    expect(count && count.mode === "counts" ? count.counts?.[0]?.count : 0).toBeGreaterThan(0);
-
-    const quiet = await searchPendingFrgMutations(repoDir, {
-      pattern: "BETA",
-      caseInsensitive: true,
-      quiet: true,
-    });
-    expect(quiet?.mode).toBe("quiet");
-    expect(quiet?.matched).toBe(true);
-  });
-
-  it("schedules background flushes without forcing sync below threshold", async () => {
-    const updatedContent = 'export const token = "abc123";\n';
-    await fs.writeFile(filePath, updatedContent, "utf8");
-    recordFrgMutation(filePath, "write", updatedContent);
-
-    expect(DEFAULT_BACKGROUND_FRG_FLUSH_DELAY_MS).toBeGreaterThan(0);
-    expect(shouldForceSynchronousFrgFlush(repoDir)).toBe(false);
-
-    scheduleBackgroundFrgFlush(repoDir, 5);
-    await new Promise((resolve) => setTimeout(resolve, 25));
-  });
-
-  it("forces sync only when pending mutations cross threshold", () => {
-    for (let i = 0; i < MAX_PENDING_MUTATIONS_BEFORE_SYNC_FLUSH - 1; i++) {
-      recordFrgMutation(path.join(repoDir, `f-${i}.ts`), "write");
-    }
-    expect(shouldForceSynchronousFrgFlush(repoDir)).toBe(false);
-
-    recordFrgMutation(
-      path.join(repoDir, `f-${MAX_PENDING_MUTATIONS_BEFORE_SYNC_FLUSH}.ts`),
-      "write",
-    );
-    expect(shouldForceSynchronousFrgFlush(repoDir)).toBe(true);
-  });
-
-  it("reports freshness snapshot and can clear/reload state boundaries", async () => {
-    const updatedContent = 'export const wal = "persisted";\n';
-    await fs.writeFile(filePath, updatedContent, "utf8");
-    recordFrgMutation(filePath, "write", updatedContent);
-
-    const pendingBefore = getPendingFrgMutations(repoDir);
-    expect(pendingBefore).toHaveLength(1);
-
-    clearPendingFrgMutations(repoDir);
-    ensureFrgRepoStateLoaded(repoDir);
-    const pendingAfter = getPendingFrgMutations(repoDir);
-    expect(pendingAfter).toHaveLength(0);
-  });
-
-  it("reads git dirty status and freshness metadata", async () => {
-    const dirtyPath = path.join(repoDir, "dirty.ts");
-    await fs.writeFile(dirtyPath, "export const dirty = true;\n", "utf8");
-
-    const dirty = getGitDirtyStatus(repoDir);
-    expect(Array.isArray(dirty.untracked)).toBe(true);
-
-    const snapshot = getFrgFreshnessSnapshot(repoDir, {
-      commit_hash: "abc",
-      tree_hash: "def",
-      age_seconds: 10,
-    });
-    expect(snapshot.freshnessState).toBeDefined();
-  });
-});

package/tests/executors/frg-merge.test.ts

@@ -1,70 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import type { ToolContext } from "../../src/types.js";
-import { clearPendingFrgMutations, recordFrgMutation } from "../../src/executors/frg-freshness.js";
-import { executeFrg } from "../../src/executors/frg.js";
-
-describe("frg search merge precedence", () => {
-  let repoDir: string;
-  let filePath: string;
-  let ctx: ToolContext;
-
-  beforeEach(async () => {
-    repoDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-frg-merge-"));
-    await fs.mkdir(path.join(repoDir, ".git"));
-    filePath = path.join(repoDir, "a.ts");
-    await fs.writeFile(filePath, 'export const version = "old";\n', "utf8");
-    clearPendingFrgMutations(repoDir);
-    ctx = {
-      workingDir: repoDir,
-      env: {},
-      confirm: async () => true,
-    };
-    await executeFrg({ command: "init", path: repoDir }, ctx);
-    await executeFrg({ command: "index", path: repoDir }, ctx);
-  });
-
-  afterEach(() => {
-    clearPendingFrgMutations(repoDir);
-  });
-
-  it("shadows indexed matches for mutated files with session delta matches", async () => {
-    const updatedContent = 'export const version = "new";\n';
-    await fs.writeFile(filePath, updatedContent, "utf8");
-    recordFrgMutation(filePath, "write", updatedContent);
-
-    const result = await executeFrg({ command: "search", path: repoDir, pattern: "version" }, ctx);
-    expect(result.success).toBe(true);
-    const data = result.data as { matches?: Array<{ file: string; content: string }> };
-    const matches = data.matches ?? [];
-    expect(matches.length).toBeGreaterThan(0);
-    expect(matches.every((match) => match.file === "a.ts")).toBe(true);
-    expect(matches.some((match) => match.content.includes("new"))).toBe(true);
-    expect(matches.some((match) => match.content.includes("old"))).toBe(false);
-  });
-
-  it("shadows indexed files/counts for mutated files", async () => {
-    const updatedContent = 'export const changed = "yes";\nexport const changedAgain = "yes";\n';
-    await fs.writeFile(filePath, updatedContent, "utf8");
-    recordFrgMutation(filePath, "write", updatedContent);
-
-    const filesOnly = await executeFrg(
-      { command: "search", path: repoDir, pattern: "changed", filesOnly: true },
-      ctx,
-    );
-    expect(filesOnly.success).toBe(true);
-    const files = (filesOnly.data as { files?: string[] }).files ?? [];
-    expect(files).toEqual(["a.ts"]);
-
-    const counts = await executeFrg(
-      { command: "search", path: repoDir, pattern: "changed", count: true },
-      ctx,
-    );
-    expect(counts.success).toBe(true);
-    const countRows =
-      (counts.data as { counts?: Array<{ file: string; count: number }> }).counts ?? [];
-    expect(countRows).toEqual([{ file: "a.ts", count: 2 }]);
-  });
-});

package/tests/executors/frg-session-content.test.ts

@@ -1,40 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import {
-  clearPendingFrgMutations,
-  recordFrgMutation,
-  searchPendingFrgMutations,
-} from "../../src/executors/frg-freshness.js";
-
-describe("frg session content cache", () => {
-  let repoDir: string;
-  let filePath: string;
-
-  beforeEach(async () => {
-    repoDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-frg-session-content-"));
-    await fs.mkdir(path.join(repoDir, ".git"));
-    filePath = path.join(repoDir, "a.ts");
-    await fs.writeFile(filePath, 'export const value = "old";\n', "utf8");
-    clearPendingFrgMutations(repoDir);
-  });
-
-  it("uses cached mutation content even if on-disk content changes before flush", async () => {
-    const sessionContent = 'export const value = "session";\n';
-    await fs.writeFile(filePath, sessionContent, "utf8");
-    recordFrgMutation(filePath, "write", sessionContent);
-
-    await fs.writeFile(filePath, 'export const value = "disk";\n', "utf8");
-
-    const result = await searchPendingFrgMutations(repoDir, {
-      pattern: "session",
-      literal: true,
-    });
-
-    expect(result?.mode).toBe("matches");
-    const matches = result && result.mode === "matches" ? (result.matches ?? []) : [];
-    expect(matches).toHaveLength(1);
-    expect(matches[0]?.content).toContain("session");
-  });
-});

package/tests/executors/frg.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import type { ToolContext } from "../../src/types.js";
-import { SpawnedProcessRegistry } from "../../src/executors/process-registry.js";
-import { executeFrg } from "../../src/executors/frg.js";
-
-const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
-
-describe("frg executor", () => {
-  let tempDir: string;
-  let ctx: ToolContext;
-  let registry: SpawnedProcessRegistry;
-  const pidsToCleanup: number[] = [];
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-frg-test-"));
-    registry = new SpawnedProcessRegistry();
-    ctx = {
-      workingDir: tempDir,
-      env: {},
-      confirm: async () => true,
-      processRegistry: registry,
-    };
-  });
-
-  afterEach(async () => {
-    for (const pid of pidsToCleanup) {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-        // ignore
-      }
-    }
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("spawns a tracked background process for watch mode", async () => {
-    const result = await executeFrg({ command: "watch", path: tempDir }, ctx);
-    if (!result.success) {
-      expect(String(result.error ?? result.message ?? "")).toContain("binary not found");
-      return;
-    }
-
-    const data = result.data as { pid?: number; watched?: boolean };
-    expect(data.watched).toBe(true);
-    expect(typeof data.pid).toBe("number");
-    if (typeof data.pid === "number") {
-      pidsToCleanup.push(data.pid);
-      expect(registry.has(data.pid)).toBe(true);
-    }
-
-    await sleep(100);
-  }, 20000);
-});

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

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