fix(insight): handle individual LLM failures in qualitative insights (#2341) (#2361)

Previously, `generateQualitativeInsights` used `Promise.all` with a
`generate` helper that re-threw errors. A single LLM call failure
(timeout, rate limit, JSON parse error) caused the entire `qualitative`
object to become `undefined`, hiding all detailed report sections.

Now individual `generate` calls catch errors and return `undefined`
instead of throwing. The `QualitativeInsights` interface fields are
made optional so partial results render correctly — each React section
component already guards against missing data with `if (!field) return
null`.

Made-with: Cursor

Author: netbrah

packages/cli/src/services/insight/generators/DataProcessor.test.ts

@@ -24,6 +24,7 @@ vi.mock('@qwen-code/qwen-code-core', async () => {
       info: vi.fn(),
       error: vi.fn(),
       warn: vi.fn(),
+      debug: vi.fn(),
     })),
   };
 });
@@ -1137,6 +1138,102 @@ describe('DataProcessor', () => {
     });
   });
 
+  describe('generateQualitativeInsights', () => {
+    const mockMetrics = {
+      totalSessions: 5,
+      totalMessages: 50,
+      totalHours: 2,
+      heatmap: { '2025-01-15': 3 },
+      topTools: [['read_file', 10]] as Array<[string, number]>,
+      activeDays: 1,
+      activeHours: { '10': 5 },
+      totalLinesAdded: 100,
+      totalLinesRemoved: 50,
+      totalFiles: 10,
+      streak: { currentStreak: 1, longestStreak: 1, dates: [] },
+    } as unknown as Omit<InsightData, 'facets' | 'qualitative'>;
+
+    const mockFacets: SessionFacets[] = [
+      {
+        session_id: 'test-1',
+        underlying_goal: 'Fix bug',
+        goal_categories: { debugging: 1 },
+        outcome: 'fully_achieved',
+        user_satisfaction_counts: { satisfied: 1 },
+        Qwen_helpfulness: 'very_helpful',
+        session_type: 'single_task',
+        friction_counts: {},
+        friction_detail: '',
+        primary_success: 'correct_code_edits',
+        brief_summary: 'Fixed a bug',
+      },
+    ];
+
+    it('should return partial qualitative data when some LLM calls fail', async () => {
+      let callIndex = 0;
+      mockGenerateJson.mockImplementation(() => {
+        callIndex++;
+        if (callIndex % 2 === 0) {
+          return Promise.reject(new Error('LLM timeout'));
+        }
+        return Promise.resolve({ intro: 'test', areas: [], opportunities: [] });
+      });
+
+      const result = await (
+        dataProcessor as unknown as {
+          generateQualitativeInsights(
+            metrics: Omit<InsightData, 'facets' | 'qualitative'>,
+            facets: SessionFacets[],
+          ): Promise<
+            | import('../types/QualitativeInsightTypes.js').QualitativeInsights
+            | undefined
+          >;
+        }
+      ).generateQualitativeInsights(mockMetrics, mockFacets);
+
+      expect(result).toBeDefined();
+      expect(result!.impressiveWorkflows).toBeDefined();
+      expect(result!.projectAreas).toBeUndefined();
+      expect(result!.futureOpportunities).toBeDefined();
+      expect(result!.frictionPoints).toBeUndefined();
+    });
+
+    it('should return undefined when facets are empty', async () => {
+      const result = await (
+        dataProcessor as unknown as {
+          generateQualitativeInsights(
+            metrics: Omit<InsightData, 'facets' | 'qualitative'>,
+            facets: SessionFacets[],
+          ): Promise<
+            | import('../types/QualitativeInsightTypes.js').QualitativeInsights
+            | undefined
+          >;
+        }
+      ).generateQualitativeInsights(mockMetrics, []);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return full qualitative data when all LLM calls succeed', async () => {
+      mockGenerateJson.mockResolvedValue({ intro: 'test', areas: [] });
+
+      const result = await (
+        dataProcessor as unknown as {
+          generateQualitativeInsights(
+            metrics: Omit<InsightData, 'facets' | 'qualitative'>,
+            facets: SessionFacets[],
+          ): Promise<
+            | import('../types/QualitativeInsightTypes.js').QualitativeInsights
+            | undefined
+          >;
+        }
+      ).generateQualitativeInsights(mockMetrics, mockFacets);
+
+      expect(result).toBeDefined();
+      expect(mockGenerateJson).toHaveBeenCalledTimes(8);
+    });
+  });
+
   describe('generateFacets', () => {
     it('should skip non-conversational sessions', async () => {
       const userOnlyRecords: ChatRecord[] = [

packages/cli/src/services/insight/generators/DataProcessor.ts

@@ -388,7 +388,7 @@ export class DataProcessor {
     const generate = async <T>(
       promptTemplate: string,
       schema: Record<string, unknown>,
-    ): Promise<T> => {
+    ): Promise<T | undefined> => {
       const prompt = `${promptTemplate}\n\n${commonData}`;
       try {
         const result = await this.config.getBaseLlmClient().generateJson({
@@ -400,7 +400,7 @@ export class DataProcessor {
         return result as T;
       } catch (error) {
         logger.error('Failed to generate insight:', error);
-        throw error;
+        return undefined;
       }
     };
 

packages/cli/src/services/insight/types/QualitativeInsightTypes.ts

@@ -71,12 +71,12 @@ export interface InsightAtAGlance {
 }
 
 export interface QualitativeInsights {
-  impressiveWorkflows: InsightImpressiveWorkflows;
-  projectAreas: InsightProjectAreas;
-  futureOpportunities: InsightFutureOpportunities;
-  frictionPoints: InsightFrictionPoints;
-  memorableMoment: InsightMemorableMoment;
-  improvements: InsightImprovements;
-  interactionStyle: InsightInteractionStyle;
-  atAGlance: InsightAtAGlance;
+  impressiveWorkflows?: InsightImpressiveWorkflows;
+  projectAreas?: InsightProjectAreas;
+  futureOpportunities?: InsightFutureOpportunities;
+  frictionPoints?: InsightFrictionPoints;
+  memorableMoment?: InsightMemorableMoment;
+  improvements?: InsightImprovements;
+  interactionStyle?: InsightInteractionStyle;
+  atAGlance?: InsightAtAGlance;
 }