@runfusion/fusion 0.23.0 → 0.25.0

package/dist/plugins/fusion-plugin-roadmap/src/__tests__/api-client.test.ts

@@ -0,0 +1,101 @@
+/* @vitest-environment jsdom */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createRoadmap,
+  createRoadmapFeature,
+  createRoadmapMilestone,
+  deleteRoadmap,
+  deleteRoadmapFeature,
+  deleteRoadmapMilestone,
+  fetchRoadmap,
+  fetchRoadmapHandoff,
+  fetchRoadmaps,
+  generateFeatureSuggestions,
+  generateMilestoneSuggestions,
+  moveRoadmapFeature,
+  reorderRoadmapFeatures,
+  reorderRoadmapMilestones,
+  updateRoadmap,
+  updateRoadmapFeature,
+  updateRoadmapMilestone,
+} from "../dashboard/api";
+
+describe("roadmap dashboard api client", () => {
+  const fetchMock = vi.fn();
+
+  beforeEach(() => {
+    vi.stubGlobal("fetch", fetchMock);
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true }),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("uses plugin namespace for roadmap CRUD wrappers", async () => {
+    await fetchRoadmaps("proj-1");
+    await fetchRoadmap("RM-1", "proj-1");
+    await createRoadmap({ title: "A" }, "proj-1");
+    await updateRoadmap("RM-1", { title: "B" }, "proj-1");
+    await deleteRoadmap("RM-1", "proj-1");
+
+    expect(fetchMock.mock.calls[0][0]).toBe("/api/plugins/roadmap-planner/roadmaps?projectId=proj-1");
+    expect(fetchMock.mock.calls[1][0]).toBe("/api/plugins/roadmap-planner/roadmaps/RM-1?projectId=proj-1");
+    expect(fetchMock.mock.calls[2][0]).toBe("/api/plugins/roadmap-planner/roadmaps?projectId=proj-1");
+    expect(fetchMock.mock.calls[3][0]).toBe("/api/plugins/roadmap-planner/roadmaps/RM-1?projectId=proj-1");
+    expect(fetchMock.mock.calls[4][0]).toBe("/api/plugins/roadmap-planner/roadmaps/RM-1?projectId=proj-1");
+  });
+
+  it("uses plugin namespace for milestone and feature reorder/move + suggestions + handoff", async () => {
+    await createRoadmapMilestone("RM-1", { title: "M" }, "proj-1");
+    await updateRoadmapMilestone("RMS-1", { title: "M2" }, "proj-1");
+    await deleteRoadmapMilestone("RMS-1", "proj-1");
+    await reorderRoadmapMilestones("RM-1", ["RMS-1", "RMS-2"], "proj-1");
+
+    await createRoadmapFeature("RMS-1", { title: "F" }, "proj-1");
+    await updateRoadmapFeature("RF-1", { title: "F2" }, "proj-1");
+    await deleteRoadmapFeature("RF-1", "proj-1");
+    await reorderRoadmapFeatures("RMS-1", ["RF-1", "RF-2"], "proj-1");
+    await moveRoadmapFeature("RF-1", "RMS-2", 0, "proj-1");
+
+    await generateMilestoneSuggestions("RM-1", "goal", 3, "proj-1");
+    await generateFeatureSuggestions("RMS-1", { prompt: "p", count: 2 }, "proj-1");
+    await fetchRoadmapHandoff("RM-1", "proj-1");
+
+    const calledUrls = fetchMock.mock.calls.map((call) => String(call[0]));
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/RM-1/milestones?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/milestones/RMS-1?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/RM-1/milestones/reorder?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/milestones/RMS-1/features/reorder?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/features/RF-1/move?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/RM-1/suggestions/milestones?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/milestones/RMS-1/suggestions/features?projectId=proj-1");
+    expect(calledUrls).toContain("/api/plugins/roadmap-planner/roadmaps/RM-1/handoff?projectId=proj-1");
+  });
+
+  it("surfaces server error body when available", async () => {
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      statusText: "Bad Request",
+      json: async () => ({ error: "invalid payload" }),
+    });
+
+    await expect(fetchRoadmaps()).rejects.toThrow("invalid payload");
+  });
+
+  it("returns undefined for 204 responses", async () => {
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 204,
+      json: async () => ({}),
+    });
+
+    await expect(deleteRoadmap("RM-1")).resolves.toBeUndefined();
+  });
+});

package/dist/plugins/fusion-plugin-roadmap/src/__tests__/index.test.ts

@@ -0,0 +1,92 @@
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { rm } from "node:fs/promises";
+import { Database } from "@fusion/core";
+import { afterEach, describe, expect, it } from "vitest";
+import plugin, {
+  RoadmapStore,
+  applyRoadmapFeatureReorder,
+  applyRoadmapMilestoneReorder,
+  mapAllFeaturesToTaskHandoffs,
+  mapFeatureToTaskHandoff,
+  mapRoadmapToMissionHandoff,
+  mapRoadmapWithHierarchyToMissionHandoff,
+  moveRoadmapFeature,
+  normalizeRoadmapFeatureOrder,
+  normalizeRoadmapMilestoneOrder,
+} from "../index.js";
+
+describe("roadmap-planner package surface", () => {
+  const tmpDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(tmpDirs.map((dir) => rm(dir, { recursive: true, force: true })));
+    tmpDirs.length = 0;
+  });
+
+  it("keeps manifest and plugin entry metadata aligned", () => {
+    const manifest = JSON.parse(readFileSync(resolve(process.cwd(), "manifest.json"), "utf8")) as {
+      id: string;
+      version: string;
+      dashboardViews?: Array<{ viewId: string }>;
+    };
+
+    expect(plugin.manifest.id).toBe(manifest.id);
+    expect(plugin.manifest.version).toBe(manifest.version);
+    expect(plugin.dashboardViews?.[0]?.viewId).toBe(manifest.dashboardViews?.[0]?.viewId);
+  });
+
+  it("declares expected package exports", () => {
+    const pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf8")) as {
+      exports: Record<string, unknown>;
+    };
+
+    expect(pkg.exports).toHaveProperty(".");
+    expect(pkg.exports).toHaveProperty("./server");
+    expect(pkg.exports).toHaveProperty("./dashboard-view");
+  });
+
+  it("exports plugin manifest with roadmap id", () => {
+    expect(plugin.manifest.id).toBe("roadmap-planner");
+  });
+
+  it("registers onSchemaInit hook that creates roadmap tables and indexes", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "roadmap-plugin-schema-test-"));
+    tmpDirs.push(tmpDir);
+
+    const db = new Database(join(tmpDir, ".fusion"), { inMemory: true });
+    db.init();
+
+    expect(plugin.hooks?.onSchemaInit).toBeTypeOf("function");
+    plugin.hooks?.onSchemaInit?.(db);
+
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all() as Array<{ name: string }>;
+    const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type = 'index'").all() as Array<{ name: string }>;
+
+    expect(tables.map((row) => row.name)).toEqual(expect.arrayContaining([
+      "roadmaps",
+      "roadmap_milestones",
+      "roadmap_features",
+    ]));
+    expect(indexes.map((row) => row.name)).toEqual(expect.arrayContaining([
+      "idxRoadmapMilestonesRoadmapOrder",
+      "idxRoadmapFeaturesMilestoneOrder",
+    ]));
+
+    db.close();
+  });
+
+  it("re-exports roadmap domain symbols", () => {
+    expect(typeof normalizeRoadmapMilestoneOrder).toBe("function");
+    expect(typeof applyRoadmapMilestoneReorder).toBe("function");
+    expect(typeof normalizeRoadmapFeatureOrder).toBe("function");
+    expect(typeof applyRoadmapFeatureReorder).toBe("function");
+    expect(typeof moveRoadmapFeature).toBe("function");
+    expect(typeof mapFeatureToTaskHandoff).toBe("function");
+    expect(typeof mapRoadmapToMissionHandoff).toBe("function");
+    expect(typeof mapRoadmapWithHierarchyToMissionHandoff).toBe("function");
+    expect(typeof mapAllFeaturesToTaskHandoffs).toBe("function");
+    expect(typeof RoadmapStore).toBe("function");
+  });
+});

package/dist/plugins/fusion-plugin-roadmap/src/__tests__/roadmap-routes.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRoadmapPluginRoutes } from "../roadmap-routes.js";
+
+function createCtx() {
+  return {
+    pluginId: "roadmap-planner",
+    taskStore: {
+      getDatabase: () => ({}),
+      getRootDir: () => "/tmp/project",
+      getRoadmapStore: () => ({
+        getRoadmap: vi.fn(() => ({ id: "RM-1", title: "R" })),
+        getMilestone: vi.fn(() => ({ id: "MS-1", roadmapId: "RM-1", title: "M" })),
+        listFeatures: vi.fn(() => []),
+      }),
+    },
+    settings: {},
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    emitEvent: vi.fn(),
+  } as any;
+}
+
+describe("createRoadmapPluginRoutes", () => {
+  it("includes PATCH roadmap routes", () => {
+    const routes = createRoadmapPluginRoutes();
+    expect(routes.some((r) => r.method === "PATCH" && r.path === "/roadmaps/:roadmapId")).toBe(true);
+  });
+
+  it("returns 400 for invalid milestone suggestions body", async () => {
+    const route = createRoadmapPluginRoutes().find((r) => r.path === "/roadmaps/:roadmapId/suggestions/milestones");
+    const result = await route!.handler({ params: { roadmapId: "RM-1" }, body: {} }, createCtx());
+    expect(result).toMatchObject({ status: 400 });
+  });
+
+  it("returns 404 for milestone suggestions when roadmap is missing", async () => {
+    const route = createRoadmapPluginRoutes().find((r) => r.path === "/roadmaps/:roadmapId/suggestions/milestones");
+    const ctx = createCtx();
+    const store = ctx.taskStore.getRoadmapStore();
+    ctx.taskStore.getRoadmapStore = () => ({ ...store, getRoadmap: vi.fn(() => null) });
+    const result = await route!.handler({ params: { roadmapId: "RM-404" }, body: { goalPrompt: "goal" } }, ctx);
+    expect(result).toMatchObject({ status: 404 });
+  });
+
+  it("returns 503 for suggestions when createAiSession is unavailable", async () => {
+    const route = createRoadmapPluginRoutes().find((r) => r.path === "/roadmaps/:roadmapId/suggestions/milestones");
+    const result = await route!.handler({ params: { roadmapId: "RM-1" }, body: { goalPrompt: "goal" } }, createCtx());
+    expect(result).toMatchObject({ status: 503 });
+  });
+});

package/dist/plugins/fusion-plugin-roadmap/src/__tests__/roadmap-suggestions.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  __resetSuggestionState,
+  __setCreateAiSessionFactory,
+  generateMilestoneSuggestions,
+  ServiceUnavailableError,
+} from "../roadmap-suggestions.js";
+
+describe("roadmap suggestion service", () => {
+  beforeEach(() => {
+    __resetSuggestionState();
+  });
+
+  it("throws when AI factory is unavailable", async () => {
+    await expect(generateMilestoneSuggestions("goal", 1, "/tmp/project")).rejects.toBeInstanceOf(ServiceUnavailableError);
+  });
+
+  it("uses PluginContext createAiSession-compatible factory", async () => {
+    const prompt = vi.fn().mockResolvedValue(undefined);
+    __setCreateAiSessionFactory(async () => ({
+      session: {
+        prompt,
+        state: { messages: [{ role: "assistant", content: '[{"title":"A"}]' }] },
+      },
+    }));
+
+    const result = await generateMilestoneSuggestions("goal", 1, "/tmp/project");
+    expect(prompt).toHaveBeenCalled();
+    expect(result[0]?.title).toBe("A");
+  });
+});