@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/tools/__tests__/query.test.ts

@@ -0,0 +1,405 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Set up test environment BEFORE any imports
+const TEST_DIR = `/tmp/flux-test-query-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const FLUX_DIR = join(TEST_DIR, ".flux");
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+// Now import modules
+import { clearAdapterCache } from "../../adapters/index.js";
+import { config } from "../../config.js";
+import { closeDb, initDb } from "../../db/index.js";
+import { createEpicTool } from "../create-epic.js";
+import { createPrdTool } from "../create-prd.js";
+import { createTaskTool } from "../create-task.js";
+import { addDependencyTool } from "../dependencies.js";
+import { getEntityTool } from "../get-entity.js";
+import { getStatsTool } from "../get-stats.js";
+import { initProjectTool } from "../init-project.js";
+import { queryEntitiesTool } from "../query-entities.js";
+
+describe("Query MCP Tools", () => {
+  beforeEach(() => {
+    closeDb();
+    config.clearCache();
+    clearAdapterCache();
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    mkdirSync(FLUX_DIR, { recursive: true });
+    writeFileSync(
+      join(FLUX_DIR, "project.json"),
+      JSON.stringify({ name: "test-project", ref_prefix: "TEST" }),
+    );
+    initDb();
+  });
+
+  afterEach(() => {
+    closeDb();
+    clearAdapterCache();
+    config.clearCache();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("get_entity", () => {
+    test("gets PRD by ref", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const result = (await getEntityTool.handler({ ref: prd.ref })) as any;
+
+      expect(result.id).toBe(prd.id);
+      expect(result.title).toBe("Test PRD");
+      expect(result.ref).toBe(prd.ref);
+    });
+
+    test("gets epic with tasks include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      await createTaskTool.handler({ epic_ref: epic.ref, title: "Task 1" });
+      await createTaskTool.handler({ epic_ref: epic.ref, title: "Task 2" });
+
+      const result = (await getEntityTool.handler({
+        ref: epic.ref,
+        include: ["tasks"],
+      })) as any;
+
+      expect(result.tasks).toBeDefined();
+      expect(result.tasks.length).toBe(2);
+    });
+
+    test("gets entity with criteria include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+        acceptance_criteria: ["Criterion 1", "Criterion 2"],
+      })) as any;
+
+      const result = (await getEntityTool.handler({
+        ref: epic.ref,
+        include: ["criteria"],
+      })) as any;
+
+      expect(result.criteria).toBeDefined();
+      expect(result.criteria.length).toBe(2);
+    });
+
+    test("gets entity with dependencies include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: epic2.ref,
+        depends_on_ref: epic1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: epic2.ref,
+        include: ["dependencies"],
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      // Dependencies now return refs directly, not objects
+      expect(result.dependencies[0]).toBe(epic1.ref);
+    });
+
+    test("returns dependencies by default for PRD without include", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: prd2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(prd1.ref);
+    });
+
+    test("returns dependencies by default for Epic without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: epic2.ref,
+        depends_on_ref: epic1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: epic2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(epic1.ref);
+    });
+
+    test("returns dependencies by default for Task without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      const task1 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 1",
+      })) as any;
+      const task2 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: task2.ref,
+        depends_on_ref: task1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: task2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(task1.ref);
+    });
+
+    test("throws error for invalid ref", async () => {
+      await expect(
+        getEntityTool.handler({ ref: "INVALID-P999" }),
+      ).rejects.toThrow("Entity not found");
+    });
+  });
+
+  describe("query_entities", () => {
+    test("queries all PRDs", async () => {
+      await createPrdTool.handler({ title: "PRD 1" });
+      await createPrdTool.handler({ title: "PRD 2" });
+
+      const result = (await queryEntitiesTool.handler({
+        type: "prd",
+      })) as any;
+      expect(result.items.length).toBe(2);
+      expect(result.total).toBe(2);
+      expect(result.has_more).toBe(false);
+    });
+
+    test("filters PRDs by status", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      await createPrdTool.handler({ title: "PRD 2" });
+
+      // Update first PRD to APPROVED
+      const { updateEntityTool } = await import("../update-entity.js");
+      await updateEntityTool.handler({
+        ref: prd1.ref,
+        fields: { status: "APPROVED" },
+      });
+
+      const result = (await queryEntitiesTool.handler({
+        type: "prd",
+        status: "DRAFT",
+      })) as any;
+      expect(result.items.length).toBe(1);
+      expect(result.total).toBe(1);
+    });
+
+    test("queries epics by PRD ref", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await createEpicTool.handler({ prd_ref: prd1.ref, title: "Epic 1" });
+      await createEpicTool.handler({ prd_ref: prd1.ref, title: "Epic 2" });
+      await createEpicTool.handler({ prd_ref: prd2.ref, title: "Epic 3" });
+
+      const result = (await queryEntitiesTool.handler({
+        type: "epic",
+        prd_ref: prd1.ref,
+      })) as any;
+      expect(result.items.length).toBe(2);
+      expect(result.total).toBe(2);
+    });
+
+    test("queries tasks by epic ref", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      await createTaskTool.handler({ epic_ref: epic1.ref, title: "Task 1" });
+      await createTaskTool.handler({ epic_ref: epic1.ref, title: "Task 2" });
+      await createTaskTool.handler({ epic_ref: epic2.ref, title: "Task 3" });
+
+      const result = (await queryEntitiesTool.handler({
+        type: "task",
+        epic_ref: epic1.ref,
+      })) as any;
+      expect(result.items.length).toBe(2);
+      expect(result.total).toBe(2);
+    });
+
+    test("includes criteria counts with entities", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const _epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+        acceptance_criteria: ["Criterion 1"],
+      })) as any;
+
+      const result = (await queryEntitiesTool.handler({
+        type: "epic",
+        include: ["criteria"],
+      })) as any;
+
+      // Now returns counts instead of full criteria array
+      expect(result.items[0].criteria_count).toBe(1);
+      expect(result.items[0].criteria_met).toBe(0);
+    });
+
+    test("supports pagination with limit and offset", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      for (let i = 1; i <= 5; i++) {
+        await createEpicTool.handler({ prd_ref: prd.ref, title: `Epic ${i}` });
+      }
+
+      const page1 = (await queryEntitiesTool.handler({
+        type: "epic",
+        limit: 2,
+        offset: 0,
+      })) as any;
+      expect(page1.items.length).toBe(2);
+      expect(page1.total).toBe(5);
+      expect(page1.has_more).toBe(true);
+
+      const page2 = (await queryEntitiesTool.handler({
+        type: "epic",
+        limit: 2,
+        offset: 2,
+      })) as any;
+      expect(page2.items.length).toBe(2);
+      expect(page2.has_more).toBe(true);
+
+      const page3 = (await queryEntitiesTool.handler({
+        type: "epic",
+        limit: 2,
+        offset: 4,
+      })) as any;
+      expect(page3.items.length).toBe(1);
+      expect(page3.has_more).toBe(false);
+    });
+  });
+
+  describe("get_stats", () => {
+    test("returns zeroes for empty project", async () => {
+      const result = (await getStatsTool.handler({})) as any;
+
+      expect(result.prds.total).toBe(0);
+      expect(result.epics.total).toBe(0);
+      expect(result.tasks.total).toBe(0);
+    });
+
+    test("counts entities by status", async () => {
+      const prd = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      await createTaskTool.handler({ epic_ref: epic.ref, title: "Task 1" });
+      await createTaskTool.handler({ epic_ref: epic.ref, title: "Task 2" });
+
+      const result = (await getStatsTool.handler({})) as any;
+
+      expect(result.prds.total).toBe(1);
+      expect(result.prds.draft).toBe(1);
+      expect(result.epics.total).toBe(1);
+      expect(result.epics.pending).toBe(1);
+      expect(result.tasks.total).toBe(2);
+      expect(result.tasks.pending).toBe(2);
+    });
+  });
+});
+
+describe("init_project", () => {
+  const INIT_TEST_DIR = `/tmp/flux-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+  beforeEach(() => {
+    closeDb();
+    config.clearCache();
+    clearAdapterCache();
+    process.env.FLUX_PROJECT_ROOT = INIT_TEST_DIR;
+    mkdirSync(INIT_TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    closeDb();
+    clearAdapterCache();
+    config.clearCache();
+    if (existsSync(INIT_TEST_DIR)) {
+      rmSync(INIT_TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  test("initializes new project", async () => {
+    const result = (await initProjectTool.handler({
+      name: "My Project",
+      vision: "Build something great",
+    })) as any;
+
+    expect(result.success).toBe(true);
+    expect(result.project.name).toBe("My Project");
+    expect(result.project.vision).toBe("Build something great");
+    expect(result.project.ref_prefix).toBeDefined();
+    expect(existsSync(join(INIT_TEST_DIR, ".flux"))).toBe(true);
+    expect(existsSync(join(INIT_TEST_DIR, ".flux", "project.json"))).toBe(true);
+    expect(existsSync(join(INIT_TEST_DIR, ".flux", "flux.db"))).toBe(true);
+  });
+
+  test("generates ref prefix from project name", async () => {
+    const result = (await initProjectTool.handler({
+      name: "My Awesome App",
+      vision: "Test vision",
+    })) as any;
+
+    // Should generate prefix like "MAA" or "MYAWE"
+    expect(result.project.ref_prefix).toBeDefined();
+    expect(result.project.ref_prefix.length).toBeGreaterThan(0);
+  });
+
+  test("fails if already initialized", async () => {
+    // First init
+    await initProjectTool.handler({
+      name: "First Project",
+      vision: "First vision",
+    });
+
+    // Second init should fail
+    await expect(
+      initProjectTool.handler({
+        name: "Second Project",
+        vision: "Second vision",
+      }),
+    ).rejects.toThrow("already initialized");
+  });
+});