@runfusion/fusion 0.25.0 → 0.27.0

package/dist/plugins/fusion-plugin-reports/src/routes/report-export-routes.ts

@@ -0,0 +1,77 @@
+import type { PluginContext, PluginRouteDefinition, PluginRouteResponse } from "@fusion/core";
+import { ReportStore } from "../store/report-store.js";
+import { renderReportHtml } from "../render/html-template.js";
+import { renderStandaloneReportHtml, slugifyReportFilename } from "../render/standalone-html.js";
+
+interface RouteRequest {
+  params: Record<string, string>;
+}
+
+const reportStoreCache = new WeakMap<object, ReportStore>();
+
+function getStore(ctx: PluginContext): ReportStore {
+  const taskStoreWithReports = ctx.taskStore as PluginContext["taskStore"] & { getReportStore?: () => ReportStore };
+  if (typeof taskStoreWithReports.getReportStore === "function") {
+    return taskStoreWithReports.getReportStore();
+  }
+  const key = ctx.taskStore as object;
+  const cached = reportStoreCache.get(key);
+  if (cached) return cached;
+  const store = new ReportStore(ctx.taskStore.getDatabase());
+  reportStoreCache.set(key, store);
+  return store;
+}
+
+function notFound(message: string): PluginRouteResponse {
+  return { status: 404, body: { error: message } };
+}
+
+function conflict(message: string): PluginRouteResponse {
+  return { status: 409, body: { error: message } };
+}
+
+export function createReportExportRoutes(): PluginRouteDefinition[] {
+  return [
+    {
+      method: "GET",
+      path: "/reports/:id/export.html",
+      handler: async (req: unknown, ctx: PluginContext): Promise<PluginRouteResponse> => {
+        const request = req as RouteRequest;
+        const id = request.params.id;
+        const store = getStore(ctx);
+        const record = store.getReport(id);
+        if (!record) return notFound(`Report ${id} not found`);
+        if (record.status === "generating") return conflict(`Report ${id} is not generated yet`);
+        const html = record.renderedHtml ?? renderStandaloneReportHtml(record);
+        if (!record.renderedHtml) {
+          store.setRenderedHtml(id, html);
+        }
+        return {
+          status: 200,
+          body: html,
+          contentType: "text/html; charset=utf-8",
+          headers: {
+            "Content-Disposition": `attachment; filename="${slugifyReportFilename(record)}"`,
+          },
+        };
+      },
+    },
+    {
+      method: "GET",
+      path: "/reports/:id/preview.html",
+      handler: async (req: unknown, ctx: PluginContext): Promise<PluginRouteResponse> => {
+        const request = req as RouteRequest;
+        const id = request.params.id;
+        const store = getStore(ctx);
+        const record = store.getReport(id);
+        if (!record) return notFound(`Report ${id} not found`);
+        if (record.status === "generating") return conflict(`Report ${id} is not generated yet`);
+        return {
+          status: 200,
+          body: renderReportHtml(record, { includeChrome: false }),
+          contentType: "text/html; charset=utf-8",
+        };
+      },
+    },
+  ];
+}

package/dist/plugins/fusion-plugin-reports/src/routes/report-list-routes.ts

@@ -0,0 +1,72 @@
+import type { PluginContext, PluginRouteDefinition, PluginRouteResponse } from "@fusion/core";
+import { ReportStore } from "../store/report-store.js";
+
+interface RouteRequest {
+  params: Record<string, string>;
+  query?: Record<string, string | string[] | undefined>;
+}
+
+const reportStoreCache = new WeakMap<object, ReportStore>();
+
+function getStore(ctx: PluginContext): ReportStore {
+  const key = ctx.taskStore as object;
+  const cached = reportStoreCache.get(key);
+  if (cached) return cached;
+  const store = new ReportStore(ctx.taskStore.getDatabase());
+  reportStoreCache.set(key, store);
+  return store;
+}
+
+function badRequest(message: string): PluginRouteResponse {
+  return { status: 400, body: { error: message } };
+}
+
+export function createReportListRoutes(): PluginRouteDefinition[] {
+  return [
+    {
+      method: "GET",
+      path: "/reports",
+      handler: async (req: unknown, ctx: PluginContext): Promise<PluginRouteResponse> => {
+        const request = req as RouteRequest;
+        const query = request.query ?? {};
+        const cadence = typeof query.cadence === "string" && query.cadence.length > 0 ? query.cadence : undefined;
+        const status = typeof query.status === "string" && query.status.length > 0 ? query.status : undefined;
+        const periodStartFrom = typeof query.from === "string" && query.from.length > 0 ? query.from : undefined;
+        const periodStartTo = typeof query.to === "string" && query.to.length > 0 ? query.to : undefined;
+        const q = typeof query.q === "string" && query.q.length > 0 ? query.q.toLowerCase() : undefined;
+        const agent = typeof query.agentId === "string" && query.agentId.length > 0 ? query.agentId.toLowerCase() : undefined;
+
+        const store = getStore(ctx);
+        const reports = store.listReports({
+          cadence: cadence as never,
+          status: status as never,
+          periodStartFrom,
+          periodStartTo,
+          orderBy: "periodStart",
+          orderDir: "desc",
+          limit: 500,
+        });
+
+        const filtered = reports.filter((report) => {
+          if (q && !report.title.toLowerCase().includes(q)) return false;
+          if (agent) {
+            const agentIds = ((report.metadata?.agentIds as string[] | undefined) ?? []).map((id) => id.toLowerCase());
+            if (!agentIds.some((id) => id.includes(agent))) return false;
+          }
+          return true;
+        });
+        return { status: 200, body: { reports: filtered } };
+      },
+    },
+    {
+      method: "GET",
+      path: "/reports/:id",
+      handler: async (req: unknown, ctx: PluginContext): Promise<PluginRouteResponse> => {
+        const request = req as RouteRequest;
+        const report = getStore(ctx).getReport(request.params.id);
+        if (!report) return { status: 404, body: { error: `Report ${request.params.id} not found` } };
+        return { status: 200, body: { report } };
+      },
+    },
+  ];
+}

package/dist/plugins/fusion-plugin-reports/src/runs-store.ts

@@ -0,0 +1,69 @@
+/**
+ * INTERIM IN-MEMORY STORE — replaced by FN-3784's persistent storage.
+ * The `ReportRunRecord` shape is intended to be a strict subset of FN-3784's eventual schema.
+ */
+import type { ReportsCadence } from "./cadence.js";
+
+export type ReportRunStatus = "queued" | "running" | "review" | "approved" | "published" | "failed";
+
+export interface ReportRunRecord {
+  id: string;
+  cadence: ReportsCadence;
+  status: ReportRunStatus;
+  createdAt: string;
+  updatedAt: string;
+  error?: string;
+  reportId?: string;
+}
+
+export interface ReportsRunsStore {
+  create(record: ReportRunRecord): Promise<ReportRunRecord>;
+  update(
+    id: string,
+    patch: Partial<Omit<ReportRunRecord, "id" | "createdAt">>,
+  ): Promise<ReportRunRecord | undefined>;
+  get(id: string): Promise<ReportRunRecord | undefined>;
+  list(limit?: number): Promise<ReportRunRecord[]>;
+}
+
+function cloneRecord(record: ReportRunRecord): ReportRunRecord {
+  return { ...record };
+}
+
+export function createInMemoryReportsRunsStore(seed: ReportRunRecord[] = []): ReportsRunsStore {
+  const records = new Map<string, ReportRunRecord>(seed.map((record) => [record.id, cloneRecord(record)]));
+
+  return {
+    async create(record) {
+      const stored = cloneRecord(record);
+      records.set(stored.id, stored);
+      return cloneRecord(stored);
+    },
+
+    async update(id, patch) {
+      const current = records.get(id);
+      if (!current) return undefined;
+
+      const next: ReportRunRecord = {
+        ...current,
+        ...patch,
+        updatedAt: patch.updatedAt ?? new Date().toISOString(),
+      };
+      records.set(id, next);
+      return cloneRecord(next);
+    },
+
+    async get(id) {
+      const record = records.get(id);
+      return record ? cloneRecord(record) : undefined;
+    },
+
+    async list(limit = 50) {
+      const clampedLimit = Math.max(0, limit);
+      return Array.from(records.values())
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+        .slice(0, clampedLimit)
+        .map((record) => cloneRecord(record));
+    },
+  };
+}

package/dist/plugins/fusion-plugin-reports/src/share-blocks.ts

@@ -0,0 +1,82 @@
+import type { Report } from "./store/report-types.js";
+
+const MAX_ITEMS_PER_SECTION = 5;
+const MAX_BLOCK_LENGTH = 1500;
+
+export interface ShareBlocks {
+  plainText: string;
+  markdown: string;
+  slack: string;
+  emailHtml: string;
+}
+
+function sliceWithEllipsis(items: string[]): string[] {
+  if (items.length <= MAX_ITEMS_PER_SECTION) return items;
+  return [...items.slice(0, MAX_ITEMS_PER_SECTION), "…"];
+}
+
+function getSections(report: Report): Array<{ heading: string; items: string[] }> {
+  const review = report.combinedReview;
+  const sections: Array<{ heading: string; items: string[] }> = [];
+  const wins = review?.mergedHighlights ?? [];
+  const highlights = review?.mergedSuggestions ?? [];
+  const lowlights = review?.mergedLowlights ?? [];
+  if (wins.length > 0) sections.push({ heading: "Wins", items: sliceWithEllipsis(wins) });
+  if (highlights.length > 0) sections.push({ heading: "Highlights", items: sliceWithEllipsis(highlights) });
+  if (lowlights.length > 0) sections.push({ heading: "Lowlights", items: sliceWithEllipsis(lowlights) });
+  return sections;
+}
+
+function trimBlock(text: string): string {
+  return text.length <= MAX_BLOCK_LENGTH ? text : `${text.slice(0, MAX_BLOCK_LENGTH - 1)}…`;
+}
+
+export function escapeMarkdown(value: string): string {
+  return value.replace(/[\\`*_{}\[\]()#+\-.!|<>]/g, "\\$&");
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+/** Builds deterministic share-ready text blocks. */
+export function buildShareBlocks(report: Report): ShareBlocks {
+  const sections = getSections(report);
+  const heading = `${report.title}\n${report.periodStart} → ${report.periodEnd}`;
+  const plainText = trimBlock([
+    heading,
+    ...sections.map((section) => `${section.heading}:\n${section.items.map((item) => `- ${item}`).join("\n")}`),
+  ].join("\n\n"));
+
+  const reportUrl = `/reports/${encodeURIComponent(report.id)}`;
+  const markdown = trimBlock([
+    `## ${escapeMarkdown(report.title)}`,
+    `Period: ${escapeMarkdown(report.periodStart)} → ${escapeMarkdown(report.periodEnd)}`,
+    ...sections.map((section) => `### ${section.heading}\n${section.items.map((item) => `- ${escapeMarkdown(item)}`).join("\n")}`),
+    `[Open report](${reportUrl})`,
+  ].join("\n\n"));
+
+  const slack = trimBlock([
+    `*${report.title}*`,
+    `${report.periodStart} → ${report.periodEnd}`,
+    ...sections.map((section) => `*${section.heading}*\n${section.items.map((item) => `• ${item}`).join("\n")}`),
+    `<${reportUrl}|Open report>`,
+  ].join("\n\n"));
+
+  // Note: emailHtml uses hardcoded hex/inline styles for email-client compatibility — design-token rule does not apply here.
+  const emailHtml = [
+    `<div style="font-family:Arial,sans-serif;color:#1f2328;line-height:1.5;">`,
+    `<h2 style="margin:0 0 12px;color:#5B8DEF;">${escapeHtml(report.title)}</h2>`,
+    `<p style="margin:0 0 12px;">Period: ${escapeHtml(report.periodStart)} → ${escapeHtml(report.periodEnd)}</p>`,
+    ...sections.map((section) => `<h3 style="margin:12px 0 6px;">${escapeHtml(section.heading)}</h3><ul style="margin:0 0 12px;padding-left:20px;">${section.items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`),
+    `<p style="margin:0;"><a href="${escapeHtml(reportUrl)}" style="color:#5B8DEF;">Open report</a></p>`,
+    `</div>`,
+  ].join("");
+
+  return { plainText, markdown, slack, emailHtml };
+}

package/dist/plugins/fusion-plugin-reports/src/store/report-store.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import type { Database } from "@fusion/core";
+import type { ApprovalDecision, ApprovalState } from "../approval.js";
 import type { CombinedReview } from "../review-types.js";
 import {
   type Report,
@@ -27,8 +28,12 @@ interface ReportRow {
   publishedAt: string | null;
   archivedAt: string | null;
   failureReason: string | null;
+  approval_state: ApprovalState;
+  approval_history: string;
   draftMarkdown: string | null;
   renderedHtmlPath: string | null;
+  rendered_html: string | null;
+  rendered_html_generated_at: string | null;
   metadataJson: string;
   combinedReviewJson: string | null;
   createdAt: string;
@@ -74,8 +79,12 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
       publishedAt: null,
       archivedAt: null,
       failureReason: null,
+      approvalState: "not_required",
+      approvalHistory: [],
       draftMarkdown: input.draftMarkdown ?? null,
       renderedHtmlPath: null,
+      renderedHtml: null,
+      renderedHtmlGeneratedAt: null,
       metadata: input.metadata ?? {},
       combinedReview: null,
       createdAt: now,
@@ -88,12 +97,14 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
           id, cadence, periodStart, periodEnd, title, status,
           generationStartedAt, generationCompletedAt, reviewStartedAt, reviewCompletedAt,
           approvedAt, approvedBy, publishedAt, archivedAt, failureReason,
-          draftMarkdown, renderedHtmlPath, metadataJson, combinedReviewJson, createdAt, updatedAt
+          approval_state, approval_history,
+          draftMarkdown, renderedHtmlPath, rendered_html, rendered_html_generated_at, metadataJson, combinedReviewJson, createdAt, updatedAt
         ) VALUES (
           @id, @cadence, @periodStart, @periodEnd, @title, @status,
           @generationStartedAt, @generationCompletedAt, @reviewStartedAt, @reviewCompletedAt,
           @approvedAt, @approvedBy, @publishedAt, @archivedAt, @failureReason,
-          @draftMarkdown, @renderedHtmlPath, @metadataJson, @combinedReviewJson, @createdAt, @updatedAt
+          @approvalState, @approvalHistory,
+          @draftMarkdown, @renderedHtmlPath, @renderedHtml, @renderedHtmlGeneratedAt, @metadataJson, @combinedReviewJson, @createdAt, @updatedAt
         )
       `).run(this.toDbParams(report, true));
     });
@@ -157,7 +168,16 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
       draftMarkdown: patch.draftMarkdown ?? current.draftMarkdown,
       renderedHtmlPath: patch.renderedHtmlPath ?? current.renderedHtmlPath,
       metadata: patch.metadata ?? current.metadata,
+      renderedHtml: patch.renderedHtml ?? current.renderedHtml,
+      renderedHtmlGeneratedAt: patch.renderedHtmlGeneratedAt ?? current.renderedHtmlGeneratedAt,
       failureReason: patch.failureReason ?? current.failureReason,
+      approvalState: patch.approvalState ?? current.approvalState,
+      approvalHistory: patch.approvalHistory ?? current.approvalHistory,
+      status: patch.status ?? current.status,
+      approvedAt: patch.approvedAt ?? current.approvedAt,
+      approvedBy: patch.approvedBy ?? current.approvedBy,
+      publishedAt: patch.publishedAt ?? current.publishedAt,
+      reviewCompletedAt: patch.reviewCompletedAt ?? current.reviewCompletedAt,
       updatedAt: new Date().toISOString(),
     };
 
@@ -224,6 +244,13 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
     return this.updateReport(id, { renderedHtmlPath: htmlPath });
   }
 
+  setRenderedHtml(id: string, html: string): Report {
+    return this.updateReport(id, {
+      renderedHtml: html,
+      renderedHtmlGeneratedAt: new Date().toISOString(),
+    });
+  }
+
   deleteReport(id: string): void {
     this.requireReport(id);
     this.db.transaction(() => {
@@ -256,8 +283,12 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
       publishedAt: row.publishedAt,
       archivedAt: row.archivedAt,
       failureReason: row.failureReason,
+      approvalState: row.approval_state,
+      approvalHistory: this.parseApprovalHistory(row.approval_history),
       draftMarkdown: row.draftMarkdown,
       renderedHtmlPath: row.renderedHtmlPath,
+      renderedHtml: row.rendered_html,
+      renderedHtmlGeneratedAt: row.rendered_html_generated_at,
       metadata: this.parseMetadata(row.metadataJson),
       combinedReview: this.parseCombinedReview(row.combinedReviewJson),
       createdAt: row.createdAt,
@@ -282,8 +313,12 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
           publishedAt = @publishedAt,
           archivedAt = @archivedAt,
           failureReason = @failureReason,
+          approval_state = @approvalState,
+          approval_history = @approvalHistory,
           draftMarkdown = @draftMarkdown,
           renderedHtmlPath = @renderedHtmlPath,
+          rendered_html = @renderedHtml,
+          rendered_html_generated_at = @renderedHtmlGeneratedAt,
           metadataJson = @metadataJson,
           combinedReviewJson = @combinedReviewJson,
           updatedAt = @updatedAt
@@ -312,8 +347,12 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
       publishedAt: report.publishedAt,
       archivedAt: report.archivedAt,
       failureReason: report.failureReason,
+      approvalState: report.approvalState,
+      approvalHistory: JSON.stringify(report.approvalHistory ?? []),
       draftMarkdown: report.draftMarkdown,
       renderedHtmlPath: report.renderedHtmlPath,
+      renderedHtml: report.renderedHtml,
+      renderedHtmlGeneratedAt: report.renderedHtmlGeneratedAt,
       metadataJson: JSON.stringify(report.metadata ?? {}),
       combinedReviewJson: report.combinedReview ? JSON.stringify(report.combinedReview) : null,
       ...(includeCreatedAt ? { createdAt: report.createdAt } : {}),
@@ -338,4 +377,14 @@ export class ReportStore extends EventEmitter<ReportStoreEvents> {
       return null;
     }
   }
+
+  private parseApprovalHistory(json: string | null): ApprovalDecision[] {
+    if (!json) return [];
+    try {
+      const parsed = JSON.parse(json);
+      return Array.isArray(parsed) ? parsed as ApprovalDecision[] : [];
+    } catch {
+      return [];
+    }
+  }
 }

package/dist/plugins/fusion-plugin-reports/src/store/report-types.ts

@@ -1,3 +1,4 @@
+import type { ApprovalDecision, ApprovalState } from "../approval.js";
 import type { CombinedReview } from "../review-types.js";
 
 export type ReportCadence = "daily" | "weekly" | "monthly" | "quarterly" | "manual";
@@ -28,8 +29,12 @@ export interface Report {
   publishedAt: string | null;
   archivedAt: string | null;
   failureReason: string | null;
+  approvalState: ApprovalState;
+  approvalHistory: ApprovalDecision[];
   draftMarkdown: string | null;
   renderedHtmlPath: string | null;
+  renderedHtml: string | null;
+  renderedHtmlGeneratedAt: string | null;
   metadata: Record<string, unknown>;
   combinedReview: CombinedReview | null;
   createdAt: string;
@@ -45,7 +50,7 @@ export interface ReportCreateInput {
   draftMarkdown?: string;
 }
 
-export type ReportUpdateInput = Partial<Pick<Report, "title" | "draftMarkdown" | "renderedHtmlPath" | "metadata" | "failureReason">>;
+export type ReportUpdateInput = Partial<Pick<Report, "title" | "draftMarkdown" | "renderedHtmlPath" | "renderedHtml" | "renderedHtmlGeneratedAt" | "metadata" | "failureReason" | "approvalState" | "approvalHistory" | "status" | "approvedAt" | "approvedBy" | "publishedAt" | "reviewCompletedAt">>;
 
 export interface ReportListFilter {
   cadence?: ReportCadence;