feat: redirect to solution view with real-time progress after 'Create Solution' (presidio-oss#252)

* refactor: Remove unused ThinkingProcess component and related logic

* feat: add workflow progress component and service for tracking solution creation

* chore: add changeset

* feat: implement workflow progress tracking for solution creation

* feat: enhance solution creation process with content generation status updates

* feat: add content generation status tracking and update workflow progress handling

* feat: remove 'requirement' type from content generation status methods

* feat: add global listener registration for workflow progress in solution creation

* feat: refactor content generation handling with new types and improved status management

* feat: enhance quit confirmation dialog during active processes with detailed information and improved messaging

* feat: change quit confirmation dialog type from question to warning for better user awareness

* feat: remove error throw for unavailable Electron API in clearAllContentGenerationProcesses method

Author: neeraj-presidio

.changeset/big-cities-wonder.md

@@ -0,0 +1,5 @@
+---
+"specif-ai": patch
+---
+
+feat: redirect to solution view with real-time progress after 'Create Solution'

electron/app.ts

@@ -1,4 +1,4 @@
-import { app, ipcMain, BrowserWindow, shell } from "electron";
+import { app, ipcMain, BrowserWindow, shell, dialog } from "electron";
 import path from "path";
 import dotenv from "dotenv";
 import { setupFileSystemHandlers } from "./handlers/fs-handler";
@@ -8,6 +8,11 @@ import { setupRequirementHandlers } from "./handlers/requirement-handler";
 import { setupVisualizationHandlers } from "./handlers/visualization-handler";
 import { setupFeatureHandlers } from "./handlers/feature-handler";
 import { setupSolutionHandlers } from "./handlers/solution-handler";
+import {
+  setupContentGenerationHandlers,
+  isAnyContentGenerationInProgress,
+  getActiveContentGenerationProcessNames,
+} from "./handlers/content-generation-handler";
 import { setupJiraHandlers } from "./handlers/jira-handler";
 import { setupAppUpdateHandler } from "./handlers/app-update-handler";
 import { setupMcpHandlers } from "./handlers/mcp-handler";
@@ -77,6 +82,18 @@ function createWindow(indexPath: string, themeConfiguration: any) {
       });
   }
 
+  mainWindow.on("close", async (event) => {
+    if (isAnyContentGenerationInProgress()) {
+      event.preventDefault();
+
+      const shouldQuit = await confirmQuitDuringActiveProcesses();
+      if (shouldQuit) {
+        mainWindow = null;
+        app.exit(0);
+      }
+    }
+  });
+
   mainWindow.on("closed", () => {
     mainWindow = null;
     app.quit();
@@ -190,6 +207,57 @@ function isValidUrl(url: string): boolean {
   }
 }
 
+async function confirmQuitDuringActiveProcesses(): Promise<boolean> {
+  const activeProcesses = getActiveContentGenerationProcessNames();
+  try {
+    const processCount = activeProcesses.length;
+    const isPlural = processCount > 1;
+
+    const displayProcesses = activeProcesses.map((name) =>
+      name.length > 30 ? `${name.substring(0, 27)}...` : name
+    );
+
+    const processListText =
+      processCount <= 3
+        ? displayProcesses.join(", ")
+        : `${displayProcesses.slice(0, 2).join(", ")} and ${
+            processCount - 2
+          } more`;
+
+    const choice = await dialog.showMessageBox(mainWindow!, {
+      type: "warning",
+      buttons: ["Wait for Completion", "Quit Anyway"],
+      defaultId: 0,
+      cancelId: 0,
+      title: `${processCount} Active ${
+        isPlural ? "Processes" : "Process"
+      } Running`,
+      message: `You have ${
+        isPlural ? "processes" : "a process"
+      } currently running that ${
+        isPlural ? "haven't" : "hasn't"
+      } finished yet.`,
+      detail: [
+        `📋 Active ${isPlural ? "processes" : "process"}: ${processListText}`,
+        "",
+        "💡 What happens if you quit now:",
+        "• Your work in progress may be lost",
+        "• Generated content might be incomplete",
+        "• You may need to restart these tasks",
+        "",
+        "🔒 Recommended: Let the processes finish, then quit safely.",
+      ].join("\n"),
+      noLink: true,
+      normalizeAccessKeys: false,
+    });
+
+    return choice.response === 1;
+  } catch (error) {
+    console.error("Error showing quit dialog:", error);
+    return false;
+  }
+}
+
 // ========================
 // MAIN APPLICATION LOGIC
 // ========================
@@ -213,6 +281,19 @@ app.whenReady().then(async () => {
 
   app.on("window-all-closed", () => app.quit());
 
+  app.on("before-quit", async (event) => {
+    console.log("App before quit...", isAnyContentGenerationInProgress());
+
+    if (isAnyContentGenerationInProgress()) {
+      event.preventDefault();
+
+      const shouldQuit = await confirmQuitDuringActiveProcesses();
+      if (shouldQuit) {
+        app.exit(0);
+      }
+    }
+  });
+
   if (mainWindow) {
     // Setup window event handlers
     setupWindowHandlers(mainWindow, indexPath);
@@ -227,6 +308,7 @@ app.whenReady().then(async () => {
     setupVisualizationHandlers();
     setupFeatureHandlers();
     setupSolutionHandlers();
+    setupContentGenerationHandlers();
     setupMcpHandlers();
 
     // start mcp servers in the background

electron/handlers/content-generation-handler.ts

@@ -0,0 +1,59 @@
+import { ipcMain } from "electron";
+import { contentGenerationManager } from "../services/content-generation/content-generation.service";
+import {
+  ContentGenerationProcess,
+  ContentGenerationType,
+} from "../types/content-generation.types";
+
+export function setupContentGenerationHandlers() {
+  ipcMain.handle(
+    "content-generation:setStatus",
+    async (
+      _event,
+      solutionId: string,
+      type: ContentGenerationType,
+      isInProgress: boolean
+    ) => {
+      contentGenerationManager.setContentGenerationStatus(
+        solutionId,
+        type,
+        isInProgress
+      );
+      return { success: true };
+    }
+  );
+
+  ipcMain.handle(
+    "content-generation:getStatus",
+    async (_event, type: ContentGenerationType) => {
+      return contentGenerationManager
+        .getActiveContentGenerationProcesses()
+        .some((p: ContentGenerationProcess) => p.type === type);
+    }
+  );
+
+  ipcMain.handle("content-generation:getActiveProcesses", async () => {
+    return contentGenerationManager.getActiveContentGenerationProcesses();
+  });
+
+  ipcMain.handle("content-generation:isAnyInProgress", async () => {
+    return contentGenerationManager.isAnyContentGenerationInProgress();
+  });
+
+  ipcMain.handle("content-generation:getActiveProcessNames", async () => {
+    return contentGenerationManager.getActiveContentGenerationProcessNames();
+  });
+
+  ipcMain.handle("content-generation:clearAll", async () => {
+    contentGenerationManager.clearAllContentGenerationProcesses();
+    return { success: true };
+  });
+}
+
+export function isAnyContentGenerationInProgress(): boolean {
+  return contentGenerationManager.isAnyContentGenerationInProgress();
+}
+
+export function getActiveContentGenerationProcessNames(): string[] {
+  return contentGenerationManager.getActiveContentGenerationProcessNames();
+}

electron/preload.ts

@@ -1,4 +1,5 @@
 import { contextBridge, ipcRenderer, IpcRendererEvent } from "electron";
+import { ContentGenerationType } from "./types/content-generation.types";
 
 type IpcListener = (event: IpcRendererEvent, ...args: any[]) => void;
 
@@ -75,6 +76,30 @@ const solutionListeners = {
     ipcRenderer.invoke("solution:createSolution", data),
 };
 
+const contentGenerationListeners = {
+  setContentGenerationStatus: (
+    solutionId: string,
+    type: ContentGenerationType,
+    isInProgress: boolean
+  ) =>
+    ipcRenderer.invoke(
+      "content-generation:setStatus",
+      solutionId,
+      type,
+      isInProgress
+    ),
+  getContentGenerationStatus: (type: ContentGenerationType) =>
+    ipcRenderer.invoke("content-generation:getStatus", type),
+  getActiveContentGenerationProcesses: () =>
+    ipcRenderer.invoke("content-generation:getActiveProcesses"),
+  isAnyContentGenerationInProgress: () =>
+    ipcRenderer.invoke("content-generation:isAnyInProgress"),
+  getActiveContentGenerationProcessNames: () =>
+    ipcRenderer.invoke("content-generation:getActiveProcessNames"),
+  clearAllContentGenerationProcesses: () =>
+    ipcRenderer.invoke("content-generation:clearAll"),
+};
+
 const appAutoUpdaterListeners = {
   checkForUpdates: () =>
     ipcRenderer.invoke("app-updater:check-for-updates"),
@@ -105,6 +130,7 @@ const electronAPI = {
   ...coreListeners,
   ...requirementListeners,
   ...solutionListeners,
+  ...contentGenerationListeners,
   ...visualizationListeners,
   ...featureListeners,
   ...appAutoUpdaterListeners,

electron/services/content-generation/content-generation.service.ts

@@ -0,0 +1,52 @@
+import {
+  ContentGenerationProcess,
+  ContentGenerationType,
+} from "../../types/content-generation.types";
+
+class ContentGenerationManager {
+  private processes: Map<string, ContentGenerationProcess> = new Map();
+
+  setContentGenerationStatus(
+    solutionId: string,
+    type: ContentGenerationType,
+    isInProgress: boolean
+  ): void {
+    const displayNames: Record<ContentGenerationType, string> = {
+      [ContentGenerationType.Solution]: "Solution Generation",
+      [ContentGenerationType.Story]: "Story Generation",
+      [ContentGenerationType.Task]: "Task Generation",
+    };
+
+    const key = `${solutionId}-${type}`;
+    this.processes.set(key, {
+      solutionId,
+      type,
+      displayName: displayNames[type],
+      isInProgress,
+    });
+  }
+
+  isAnyContentGenerationInProgress(): boolean {
+    return Array.from(this.processes.values()).some(
+      (process) => process.isInProgress
+    );
+  }
+
+  getActiveContentGenerationProcesses(): ContentGenerationProcess[] {
+    return Array.from(this.processes.values()).filter(
+      (process) => process.isInProgress
+    );
+  }
+
+  getActiveContentGenerationProcessNames(): string[] {
+    return this.getActiveContentGenerationProcesses().map(
+      (process) => process.displayName
+    );
+  }
+
+  clearAllContentGenerationProcesses(): void {
+    this.processes.clear();
+  }
+}
+
+export const contentGenerationManager = new ContentGenerationManager();

electron/types/content-generation.types.ts

@@ -0,0 +1,12 @@
+export enum ContentGenerationType {
+  Solution = 'solution',
+  Story = 'story',
+  Task = 'task',
+}
+
+export interface ContentGenerationProcess {
+  solutionId: string;
+  type: ContentGenerationType;
+  displayName: string;
+  isInProgress: boolean;
+}

ui/package-lock.json

@@ -65,7 +65,6 @@
     "@tiptap/extension-paragraph": "^2.11.5",
     "@tiptap/extension-text": "^2.11.5",
     "@tiptap/pm": "^2.11.5",
-    "canvas-confetti": "^1.9.3",
     "dotenv": "^16.4.5",
     "exceljs": "^4.4.0",
     "file-saver": "^2.0.5",
@@ -98,7 +97,6 @@
     "@angular/compiler-cli": "^16.2.0",
     "@rrweb/types": "^2.0.0-alpha.16",
     "@tailwindcss/typography": "^0.5.16",
-    "@types/canvas-confetti": "^1.9.0",
     "@types/d3": "^7.4.3",
     "@types/dompurify": "~3.0.5",
     "@types/file-saver": "^2.0.7",