@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/__tests__/version.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+describe("version module", () => {
+  test("VERSION is exported from src/version.ts", async () => {
+    // Dynamic import to get the VERSION constant
+    const versionModule = await import("../version.js");
+
+    expect(versionModule.VERSION).toBeDefined();
+    expect(typeof versionModule.VERSION).toBe("string");
+  });
+
+  test("VERSION equals package.json version", async () => {
+    // Read package.json version
+    const packageJsonPath = join(process.cwd(), "package.json");
+    expect(existsSync(packageJsonPath)).toBe(true);
+
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageVersion = packageJson.version;
+
+    expect(packageVersion).toBeDefined();
+    expect(typeof packageVersion).toBe("string");
+
+    // Import VERSION and compare
+    const versionModule = await import("../version.js");
+    expect(versionModule.VERSION).toBe(packageVersion);
+  });
+
+  test("VERSION is a valid semver format", async () => {
+    const versionModule = await import("../version.js");
+
+    // Basic semver format check (e.g., "0.1.0", "1.2.3-beta.1")
+    const semverPattern = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+    expect(semverPattern.test(versionModule.VERSION)).toBe(true);
+  });
+});

package/src/dashboard/__tests__/api.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Dashboard API endpoint tests
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+const TEST_DIR = `/tmp/flux-dashboard-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+import { clearAdapterCache } from "../../server/adapters/factory.js";
+import { getAdapter } from "../../server/adapters/index.js";
+import { initDb } from "../../server/db/index.js";
+import { startDashboard } from "../server.js";
+
+let dashboardUrl: string;
+let stopDashboard: () => void;
+
+beforeAll(async () => {
+  mkdirSync(`${TEST_DIR}/.flux/prds`, { recursive: true });
+
+  writeFileSync(
+    `${TEST_DIR}/.flux/project.json`,
+    JSON.stringify({
+      name: "test-project",
+      vision: "Test vision",
+      ref_prefix: "TEST",
+      project_root: TEST_DIR,
+      created_at: new Date().toISOString(),
+      adapter: { type: "local" },
+    }),
+  );
+
+  initDb();
+  clearAdapterCache();
+
+  const adapter = getAdapter();
+  const prd = await adapter.createPrd({
+    title: "Test PRD",
+    description: "Test description",
+    tag: "test-tag",
+  });
+
+  const epic = await adapter.createEpic({
+    prdRef: prd.ref,
+    title: "Test Epic",
+    description: "Epic description",
+  });
+
+  await adapter.createTask({
+    epicRef: epic.ref,
+    title: "Test Task",
+    description: "Task description",
+    priority: "HIGH",
+  });
+
+  const { port, stop } = await startDashboard();
+  dashboardUrl = `http://localhost:${port}`;
+  stopDashboard = stop;
+});
+
+afterAll(() => {
+  stopDashboard();
+  clearAdapterCache();
+  rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+describe("Dashboard API", () => {
+  describe("GET /api/tree", () => {
+    test("returns hierarchical tree structure", async () => {
+      const response = await fetch(`${dashboardUrl}/api/tree`);
+      expect(response.status).toBe(200);
+
+      const tree = await response.json();
+      expect(Array.isArray(tree)).toBe(true);
+      expect(tree.length).toBeGreaterThan(0);
+
+      const prd = tree[0];
+      expect(prd.ref).toMatch(/^TEST-P\d+$/);
+      expect(prd.title).toBe("Test PRD");
+      expect(prd.epics).toBeDefined();
+      expect(prd.epics.length).toBe(1);
+
+      const epic = prd.epics[0];
+      expect(epic.ref).toMatch(/^TEST-E\d+$/);
+      expect(epic.tasks).toBeDefined();
+      expect(epic.tasks.length).toBe(1);
+    });
+  });
+
+  describe("GET /api/prd/:ref", () => {
+    test("returns PRD details", async () => {
+      const treeResponse = await fetch(`${dashboardUrl}/api/tree`);
+      const tree = await treeResponse.json();
+      const prdRef = tree[0].ref;
+
+      const response = await fetch(`${dashboardUrl}/api/prd/${prdRef}`);
+      expect(response.status).toBe(200);
+
+      const prd = await response.json();
+      expect(prd.ref).toBe(prdRef);
+      expect(prd.title).toBe("Test PRD");
+      expect(prd.description).toBe("Test description");
+    });
+
+    test("returns 404 for non-existent PRD", async () => {
+      const response = await fetch(`${dashboardUrl}/api/prd/TEST-P999`);
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe("GET /api/epic/:ref", () => {
+    test("returns epic details with criteria", async () => {
+      const treeResponse = await fetch(`${dashboardUrl}/api/tree`);
+      const tree = await treeResponse.json();
+      const epicRef = tree[0].epics[0].ref;
+
+      const response = await fetch(`${dashboardUrl}/api/epic/${epicRef}`);
+      expect(response.status).toBe(200);
+
+      const epic = await response.json();
+      expect(epic.ref).toBe(epicRef);
+      expect(epic.title).toBe("Test Epic");
+      expect(epic.criteria).toBeDefined();
+    });
+
+    test("returns 404 for non-existent epic", async () => {
+      const response = await fetch(`${dashboardUrl}/api/epic/TEST-E999`);
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe("GET /api/task/:ref", () => {
+    test("returns task details with criteria and dependencies", async () => {
+      const treeResponse = await fetch(`${dashboardUrl}/api/tree`);
+      const tree = await treeResponse.json();
+      const taskRef = tree[0].epics[0].tasks[0].ref;
+
+      const response = await fetch(`${dashboardUrl}/api/task/${taskRef}`);
+      expect(response.status).toBe(200);
+
+      const task = await response.json();
+      expect(task.ref).toBe(taskRef);
+      expect(task.title).toBe("Test Task");
+      expect(task.priority).toBe("HIGH");
+      expect(task.criteria).toBeDefined();
+      expect(task.dependencies).toBeDefined();
+    });
+
+    test("returns 404 for non-existent task", async () => {
+      const response = await fetch(`${dashboardUrl}/api/task/TEST-T999`);
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe("GET /api/tags", () => {
+    test("returns tag list with counts", async () => {
+      const response = await fetch(`${dashboardUrl}/api/tags`);
+      expect(response.status).toBe(200);
+
+      const tags = await response.json();
+      expect(Array.isArray(tags)).toBe(true);
+
+      const allTag = tags.find((t: { tag: string }) => t.tag === "All");
+      expect(allTag).toBeDefined();
+      expect(allTag.count).toBeGreaterThan(0);
+
+      const testTag = tags.find((t: { tag: string }) => t.tag === "test-tag");
+      expect(testTag).toBeDefined();
+      expect(testTag.count).toBe(1);
+    });
+  });
+
+  describe("GET /api/dependencies", () => {
+    test("returns dependency edges", async () => {
+      const response = await fetch(`${dashboardUrl}/api/dependencies`);
+      expect(response.status).toBe(200);
+
+      const data = await response.json();
+      expect(data.edges).toBeDefined();
+      expect(Array.isArray(data.edges)).toBe(true);
+    });
+  });
+
+  describe("Static files", () => {
+    test("serves index.html at root", async () => {
+      const response = await fetch(`${dashboardUrl}/`);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("text/html");
+    });
+
+    test("serves CSS files", async () => {
+      const response = await fetch(`${dashboardUrl}/styles.css`);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe("text/css");
+    });
+
+    test("serves JS files", async () => {
+      const response = await fetch(`${dashboardUrl}/app.js`);
+      expect(response.status).toBe(200);
+      expect(response.headers.get("content-type")).toBe(
+        "application/javascript",
+      );
+    });
+
+    test("returns 404 for non-existent files", async () => {
+      const response = await fetch(`${dashboardUrl}/nonexistent.txt`);
+      expect(response.status).toBe(404);
+    });
+  });
+});

package/src/dashboard/browser.ts

@@ -0,0 +1,35 @@
+/**
+ * Cross-platform Browser Opening
+ *
+ * Opens the default browser to the dashboard URL on macOS, Linux, and Windows.
+ */
+
+export async function openBrowser(url: string): Promise<void> {
+  const platform = process.platform;
+
+  let command: string[];
+
+  switch (platform) {
+    case "darwin":
+      command = ["open", url];
+      break;
+    case "win32":
+      command = ["cmd", "/c", "start", url];
+      break;
+    default:
+      // Linux and others
+      command = ["xdg-open", url];
+      break;
+  }
+
+  try {
+    const proc = Bun.spawn(command, {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    await proc.exited;
+  } catch {
+    console.log(`Could not open browser automatically.`);
+    console.log(`Please open manually: ${url}`);
+  }
+}