@runfusion/fusion 0.22.0 → 0.24.0

package/dist/plugins/fusion-plugin-reports/src/__tests__/manifest.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import manifest from "../../manifest.json";
+import plugin from "../index.js";
+
+const expectedKeys = [
+  "dailyEnabled",
+  "dailyCron",
+  "weeklyEnabled",
+  "weeklyCron",
+  "timezone",
+  "generationPromptDaily",
+  "generationPromptWeekly",
+  "reviewPrompt",
+  "reviewPanelAgentIds",
+  "reviewMinApprovals",
+  "reviewBlockingMode",
+  "sectionOrder",
+  "enabledSections",
+  "includeSystemSummary",
+  "includePerAgentSections",
+  "brandTitle",
+  "brandLogoUrl",
+  "themeMode",
+  "accentColor",
+  "approvalRequired",
+  "autoPublishOnApproval",
+  "approverAgentIds",
+  "publishTargets",
+] as const;
+
+describe("reports plugin manifest", () => {
+  it("exports expected plugin id", () => {
+    expect(plugin.manifest.id).toBe("fusion-plugin-reports");
+  });
+
+  it("keeps runtime manifest metadata aligned with manifest.json", () => {
+    expect(plugin.manifest.id).toBe(manifest.id);
+    expect(plugin.manifest.name).toBe(manifest.name);
+    expect(plugin.manifest.version).toBe(manifest.version);
+    expect(plugin.manifest.description).toBe(manifest.description);
+    expect(plugin.manifest.author).toBe(manifest.author);
+    expect(plugin.manifest.fusionVersion).toBe(manifest.fusionVersion);
+  });
+
+  it("includes full settings schema", () => {
+    expect(plugin.manifest.settingsSchema).toBeDefined();
+    for (const key of expectedKeys) {
+      expect(plugin.manifest.settingsSchema).toHaveProperty(key);
+    }
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/__tests__/review-panel.test.ts

@@ -0,0 +1,166 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { CreateAiSessionFactory, PluginContext } from "@fusion/core";
+import { __setCreateAiSessionFactory, combineReviews, runReviewPanel } from "../review-panel.js";
+import type { ReviewPanelMember } from "../review-types.js";
+import { ReviewPanelError } from "../review-types.js";
+
+function createContext(createAiSession?: CreateAiSessionFactory): PluginContext {
+  return {
+    pluginId: "fusion-plugin-reports",
+    taskStore: {} as PluginContext["taskStore"],
+    settings: {},
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    emitEvent: vi.fn(),
+    createAiSession,
+  };
+}
+
+const panel: ReviewPanelMember[] = [
+  { id: "qa", name: "QA", perspective: "Quality" },
+  { id: "ops", name: "Ops", perspective: "Operations" },
+  { id: "pm", name: "PM", perspective: "Product" },
+];
+
+afterEach(() => {
+  __setCreateAiSessionFactory(undefined);
+  vi.restoreAllMocks();
+  vi.useRealTimers();
+});
+
+describe("runReviewPanel", () => {
+  it("returns individual and combined reviews for a 3-member panel", async () => {
+    const createAiSession = vi.fn(async ({ systemPrompt }) => ({
+      session: {
+        prompt: vi.fn(async () => {}),
+        state: {
+          messages: [{ role: "assistant", content: JSON.stringify({ verdict: "approve", summary: systemPrompt, highlights: ["A"], lowlights: ["B"], suggestions: ["C"] }) }],
+        },
+        dispose: vi.fn(),
+      },
+    }));
+
+    const result = await runReviewPanel({
+      reportDraft: "draft",
+      reportMetadata: { reportId: "r-1", cadence: "daily", periodStart: "2026-01-01", periodEnd: "2026-01-02" },
+      panel,
+      cwd: "/tmp",
+    }, createContext(createAiSession));
+
+    expect(result.individual).toHaveLength(3);
+    expect(result.failures).toEqual([]);
+    expect(result.overallVerdict).toBe("approve");
+    expect(result.consensusSummary).toContain("Quality:");
+  });
+
+  it("deduplicates merged arrays in first-seen order", () => {
+    const merged = combineReviews([
+      { memberId: "a", memberName: "A", perspective: "P1", verdict: "approve", summary: "ok", highlights: [" Alpha ", "Beta"], lowlights: ["Lag"], suggestions: ["Fix docs"], rawText: "", durationMs: 1 },
+      { memberId: "b", memberName: "B", perspective: "P2", verdict: "approve", summary: "ok", highlights: ["alpha", "Gamma"], lowlights: [" lag "], suggestions: ["fix docs", "Add tests"], rawText: "", durationMs: 1 },
+    ], []);
+
+    expect(merged.mergedHighlights).toEqual(["Alpha", "Beta", "Gamma"]);
+    expect(merged.mergedLowlights).toEqual(["Lag"]);
+    expect(merged.mergedSuggestions).toEqual(["Fix docs", "Add tests"]);
+  });
+
+  it("applies verdict precedence", () => {
+    const revise = combineReviews([
+      { memberId: "a", memberName: "A", perspective: "P1", verdict: "approve", summary: "ok", highlights: [], lowlights: [], suggestions: [], rawText: "", durationMs: 1 },
+      { memberId: "b", memberName: "B", perspective: "P2", verdict: "revise", summary: "rev", highlights: [], lowlights: [], suggestions: [], rawText: "", durationMs: 1 },
+    ], []);
+    expect(revise.overallVerdict).toBe("revise");
+
+    const reject = combineReviews([
+      { memberId: "a", memberName: "A", perspective: "P1", verdict: "approve", summary: "ok", highlights: [], lowlights: [], suggestions: [], rawText: "", durationMs: 1 },
+      { memberId: "b", memberName: "B", perspective: "P2", verdict: "reject", summary: "no", highlights: [], lowlights: [], suggestions: [], rawText: "", durationMs: 1 },
+    ], []);
+    expect(reject.overallVerdict).toBe("reject");
+  });
+
+  it("records timeout failure without aborting other reviewers", async () => {
+    vi.useFakeTimers();
+    const createAiSession = vi.fn(async ({ systemPrompt }) => {
+      if (systemPrompt.includes("Operations")) {
+        return {
+          session: {
+            prompt: vi.fn(async () => new Promise(() => {})),
+            state: { messages: [] },
+            dispose: vi.fn(),
+          },
+        };
+      }
+      return {
+        session: {
+          prompt: vi.fn(async () => {}),
+          state: { messages: [{ role: "assistant", content: JSON.stringify({ verdict: "approve", summary: "ok", highlights: [], lowlights: [], suggestions: [] }) }] },
+          dispose: vi.fn(),
+        },
+      };
+    });
+
+    const promise = runReviewPanel({
+      reportDraft: "draft",
+      reportMetadata: { reportId: "r-1", cadence: "daily", periodStart: "2026-01-01", periodEnd: "2026-01-02" },
+      panel,
+      cwd: "/tmp",
+    }, createContext(createAiSession));
+
+    await vi.advanceTimersByTimeAsync(120_000);
+    const result = await promise;
+
+    expect(result.individual).toHaveLength(2);
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0]?.reason).toBe("timeout");
+  });
+
+  it("retries malformed JSON once then reports parse_error", async () => {
+    const prompt = vi.fn(async () => {});
+    const createAiSession = vi.fn(async () => ({
+      session: {
+        prompt,
+        state: { messages: [{ role: "assistant", content: "not-json" }] },
+        dispose: vi.fn(),
+      },
+    }));
+
+    const result = await runReviewPanel({
+      reportDraft: "draft",
+      reportMetadata: { reportId: "r-1", cadence: "daily", periodStart: "2026-01-01", periodEnd: "2026-01-02" },
+      panel: [panel[0]],
+      cwd: "/tmp",
+    }, createContext(createAiSession));
+
+    expect(prompt).toHaveBeenCalledTimes(2);
+    expect(result.individual).toEqual([]);
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0]?.reason).toBe("parse_error");
+  });
+
+  it("throws ReviewPanelError when createAiSession is unavailable", async () => {
+    await expect(runReviewPanel({
+      reportDraft: "draft",
+      reportMetadata: { reportId: "r-1", cadence: "daily", periodStart: "2026-01-01", periodEnd: "2026-01-02" },
+      panel,
+      cwd: "/tmp",
+    }, createContext(undefined))).rejects.toBeInstanceOf(ReviewPanelError);
+  });
+
+  it("forwards provider/modelId to createAiSession per member", async () => {
+    const createAiSession = vi.fn(async () => ({
+      session: {
+        prompt: vi.fn(async () => {}),
+        state: { messages: [{ role: "assistant", content: JSON.stringify({ verdict: "approve", summary: "ok", highlights: [], lowlights: [], suggestions: [] }) }] },
+        dispose: vi.fn(),
+      },
+    }));
+
+    await runReviewPanel({
+      reportDraft: "draft",
+      reportMetadata: { reportId: "r-1", cadence: "daily", periodStart: "2026-01-01", periodEnd: "2026-01-02" },
+      panel: [{ id: "m1", name: "M1", perspective: "P", provider: "anthropic", modelId: "claude" }],
+      cwd: "/tmp",
+    }, createContext(createAiSession));
+
+    expect(createAiSession).toHaveBeenCalledWith(expect.objectContaining({ defaultProvider: "anthropic", defaultModelId: "claude" }));
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/__tests__/settings.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+import type { PluginSettingType } from "@fusion/plugin-sdk";
+import {
+  DEFAULT_ACCENT_COLOR,
+  DEFAULT_AUTO_PUBLISH_ON_APPROVAL,
+  DEFAULT_BRAND_TITLE,
+  DEFAULT_DAILY_CRON,
+  DEFAULT_DAILY_ENABLED,
+  DEFAULT_ENABLED_SECTIONS,
+  DEFAULT_GENERATION_PROMPT_DAILY,
+  DEFAULT_GENERATION_PROMPT_WEEKLY,
+  DEFAULT_INCLUDE_PER_AGENT_SECTIONS,
+  DEFAULT_INCLUDE_SYSTEM_SUMMARY,
+  DEFAULT_PUBLISH_TARGETS,
+  DEFAULT_REVIEW_BLOCKING_MODE,
+  DEFAULT_REVIEW_MIN_APPROVALS,
+  DEFAULT_REVIEW_PROMPT,
+  DEFAULT_SECTION_ORDER,
+  DEFAULT_THEME_MODE,
+  DEFAULT_TIMEZONE,
+  DEFAULT_WEEKLY_CRON,
+  DEFAULT_WEEKLY_ENABLED,
+  getAccentColor,
+  getApprovalRequired,
+  getApproverAgentIds,
+  getAutoPublishOnApproval,
+  getBrandLogoUrl,
+  getBrandTitle,
+  getDailyCron,
+  getDailyEnabled,
+  getEnabledSections,
+  getGenerationPromptDaily,
+  getGenerationPromptWeekly,
+  getIncludePerAgentSections,
+  getIncludeSystemSummary,
+  getPublishTargets,
+  getReviewBlockingMode,
+  getReviewMinApprovals,
+  getReviewPanelAgentIds,
+  getReviewPrompt,
+  getSectionOrder,
+  getThemeMode,
+  getTimezone,
+  getWeeklyCron,
+  getWeeklyEnabled,
+  settingsSchema,
+} from "../settings.js";
+
+const VALID_TYPES: PluginSettingType[] = ["string", "number", "boolean", "enum", "password", "array"];
+
+describe("reports plugin settings schema", () => {
+  it("uses only valid plugin setting types and labels", () => {
+    for (const [key, schema] of Object.entries(settingsSchema)) {
+      expect(VALID_TYPES).toContain(schema.type);
+      expect(typeof schema.label).toBe("string");
+      expect(schema.label?.trim().length).toBeGreaterThan(0);
+
+      if (schema.type === "enum") {
+        expect(Array.isArray(schema.enumValues)).toBe(true);
+        expect(schema.enumValues?.length ?? 0).toBeGreaterThan(0);
+      }
+
+      if (schema.type === "array") {
+        expect(schema.itemType).toBe("string");
+      }
+
+      expect(key.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("uses documented literal defaults", () => {
+    expect(settingsSchema.dailyCron.defaultValue).toBe("0 8 * * *");
+    expect(settingsSchema.weeklyCron.defaultValue).toBe("0 8 * * 1");
+    expect(settingsSchema.timezone.defaultValue).toBe("UTC");
+    expect(settingsSchema.themeMode.defaultValue).toBe("auto");
+    expect(settingsSchema.brandTitle.defaultValue).toBe("Fusion Activity Report");
+  });
+
+  it("returns defaults for empty settings", () => {
+    const empty = {};
+    expect(getDailyEnabled(empty)).toBe(DEFAULT_DAILY_ENABLED);
+    expect(getDailyCron(empty)).toBe(DEFAULT_DAILY_CRON);
+    expect(getWeeklyEnabled(empty)).toBe(DEFAULT_WEEKLY_ENABLED);
+    expect(getWeeklyCron(empty)).toBe(DEFAULT_WEEKLY_CRON);
+    expect(getTimezone(empty)).toBe(DEFAULT_TIMEZONE);
+    expect(getGenerationPromptDaily(empty)).toBe(DEFAULT_GENERATION_PROMPT_DAILY);
+    expect(getGenerationPromptWeekly(empty)).toBe(DEFAULT_GENERATION_PROMPT_WEEKLY);
+    expect(getReviewPrompt(empty)).toBe(DEFAULT_REVIEW_PROMPT);
+    expect(getReviewPanelAgentIds(empty)).toEqual([]);
+    expect(getReviewMinApprovals(empty)).toBe(DEFAULT_REVIEW_MIN_APPROVALS);
+    expect(getReviewBlockingMode(empty)).toBe(DEFAULT_REVIEW_BLOCKING_MODE);
+    expect(getSectionOrder(empty)).toEqual(DEFAULT_SECTION_ORDER);
+    expect(getEnabledSections(empty)).toEqual(DEFAULT_ENABLED_SECTIONS);
+    expect(getIncludeSystemSummary(empty)).toBe(DEFAULT_INCLUDE_SYSTEM_SUMMARY);
+    expect(getIncludePerAgentSections(empty)).toBe(DEFAULT_INCLUDE_PER_AGENT_SECTIONS);
+    expect(getBrandTitle(empty)).toBe(DEFAULT_BRAND_TITLE);
+    expect(getBrandLogoUrl(empty)).toBeUndefined();
+    expect(getThemeMode(empty)).toBe(DEFAULT_THEME_MODE);
+    expect(getAccentColor(empty)).toBe(DEFAULT_ACCENT_COLOR);
+    expect(getApprovalRequired(empty)).toBe(false);
+    expect(getAutoPublishOnApproval(empty)).toBe(DEFAULT_AUTO_PUBLISH_ON_APPROVAL);
+    expect(getApproverAgentIds(empty)).toEqual([]);
+    expect(getPublishTargets(empty)).toEqual(DEFAULT_PUBLISH_TARGETS);
+  });
+
+  it("returns configured values when provided", () => {
+    const populated = {
+      dailyEnabled: false,
+      dailyCron: "5 9 * * *",
+      weeklyEnabled: false,
+      weeklyCron: "15 7 * * 2",
+      timezone: "America/New_York",
+      generationPromptDaily: "daily prompt",
+      generationPromptWeekly: "weekly prompt",
+      reviewPrompt: "review prompt",
+      reviewPanelAgentIds: ["agent-a", "agent-b"],
+      reviewMinApprovals: 3,
+      reviewBlockingMode: "block",
+      sectionOrder: ["highlights", "wins"],
+      enabledSections: ["wins"],
+      includeSystemSummary: false,
+      includePerAgentSections: false,
+      brandTitle: "Custom Report",
+      brandLogoUrl: "https://example.com/logo.png",
+      themeMode: "dark",
+      accentColor: "#123456",
+      approvalRequired: true,
+      autoPublishOnApproval: false,
+      approverAgentIds: ["approver-a"],
+      publishTargets: ["dashboard", "html-export"],
+    } satisfies Record<string, unknown>;
+
+    expect(getDailyEnabled(populated)).toBe(false);
+    expect(getDailyCron(populated)).toBe("5 9 * * *");
+    expect(getWeeklyEnabled(populated)).toBe(false);
+    expect(getWeeklyCron(populated)).toBe("15 7 * * 2");
+    expect(getTimezone(populated)).toBe("America/New_York");
+    expect(getGenerationPromptDaily(populated)).toBe("daily prompt");
+    expect(getGenerationPromptWeekly(populated)).toBe("weekly prompt");
+    expect(getReviewPrompt(populated)).toBe("review prompt");
+    expect(getReviewPanelAgentIds(populated)).toEqual(["agent-a", "agent-b"]);
+    expect(getReviewMinApprovals(populated)).toBe(3);
+    expect(getReviewBlockingMode(populated)).toBe("block");
+    expect(getSectionOrder(populated)).toEqual(["highlights", "wins"]);
+    expect(getEnabledSections(populated)).toEqual(["wins"]);
+    expect(getIncludeSystemSummary(populated)).toBe(false);
+    expect(getIncludePerAgentSections(populated)).toBe(false);
+    expect(getBrandTitle(populated)).toBe("Custom Report");
+    expect(getBrandLogoUrl(populated)).toBe("https://example.com/logo.png");
+    expect(getThemeMode(populated)).toBe("dark");
+    expect(getAccentColor(populated)).toBe("#123456");
+    expect(getApprovalRequired(populated)).toBe(true);
+    expect(getAutoPublishOnApproval(populated)).toBe(false);
+    expect(getApproverAgentIds(populated)).toEqual(["approver-a"]);
+    expect(getPublishTargets(populated)).toEqual(["dashboard", "html-export"]);
+  });
+});

package/dist/plugins/fusion-plugin-reports/src/index.ts

@@ -0,0 +1,41 @@
+import type { PluginContext } from "@fusion/core";
+import { definePlugin } from "@fusion/plugin-sdk";
+import { runReviewPanel } from "./review-panel.js";
+import type { CombinedReview, ReviewPanelMember, RunReviewPanelInput } from "./review-types.js";
+import { settingsSchema } from "./settings.js";
+
+const plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-reports",
+    name: "Reports",
+    version: "0.1.0",
+    description: "Generates beautiful HTML system-activity reports with multi-agent review.",
+    author: "Fusion Team",
+    fusionVersion: ">=0.1.0",
+    settingsSchema,
+  },
+  state: "installed",
+  hooks: {},
+});
+
+export interface RunGeneratedReportReviewInput {
+  reportDraft: string;
+  reportMetadata: RunReviewPanelInput["reportMetadata"];
+  panel: ReviewPanelMember[];
+  cwd: string;
+}
+
+export async function runGeneratedReportReview(input: RunGeneratedReportReviewInput, ctx: PluginContext): Promise<CombinedReview> {
+  return runReviewPanel({
+    reportDraft: input.reportDraft,
+    reportMetadata: input.reportMetadata,
+    panel: input.panel,
+    cwd: input.cwd,
+  }, ctx);
+}
+
+export default plugin;
+
+export * from "./settings.js";
+export * from "./review-types.js";
+export * from "./review-panel.js";