fix(ai): 保留拆解生成结果

apps/web/lib/ai-decompose-session.test.ts

@@ -0,0 +1,72 @@
+import { strict as assert } from 'node:assert';
+import test from 'node:test';
+import type { AgentDecomposeResponse } from '@ftb/shared';
+import {
+  createAiDecomposeSessionStore,
+  getAiDecomposeButtonMode,
+  type AiDecomposeCompletedPayload,
+} from './ai-decompose-session';
+
+const response: AgentDecomposeResponse = {
+  ok: true,
+  result: {
+    report: { matched: [], reqOnly: [], noteOnly: [], ambiguous: [] },
+    devTaskDrafts: [],
+    testCaseDrafts: [],
+  },
+  meta: { model: 'test-model', inputTokens: 10, outputTokens: 5, durationMs: 1200 },
+};
+
+const payload: AiDecomposeCompletedPayload = {
+  result: response,
+  dedupeSummary: { removedDevTaskCount: 0, removedTestCaseCount: 0 },
+};
+
+test('keeps generated result after request finishes outside the button component', async () => {
+  const store = createAiDecomposeSessionStore();
+  let resolveRequest!: (value: AiDecomposeCompletedPayload) => void;
+  const request = new Promise<AiDecomposeCompletedPayload>((resolve) => {
+    resolveRequest = resolve;
+  });
+
+  const running = store.start('plan-1', 'dev_tasks', () => request);
+
+  assert.equal(store.get('plan-1', 'dev_tasks').status, 'generating');
+  assert.equal(getAiDecomposeButtonMode(store.get('plan-1', 'dev_tasks')), 'generating');
+
+  resolveRequest(payload);
+  await running;
+
+  const completed = store.get('plan-1', 'dev_tasks');
+  assert.equal(completed.status, 'completed');
+  assert.deepEqual(completed.payload, payload);
+  assert.equal(getAiDecomposeButtonMode(completed), 'view_result');
+});
+
+test('keeps completed result until user adopts or rejects it', async () => {
+  const store = createAiDecomposeSessionStore();
+
+  await store.start('plan-1', 'test_cases', async () => payload);
+  assert.equal(getAiDecomposeButtonMode(store.get('plan-1', 'test_cases')), 'view_result');
+
+  store.markReviewed('plan-1', 'test_cases');
+
+  assert.equal(store.get('plan-1', 'test_cases').status, 'idle');
+  assert.equal(getAiDecomposeButtonMode(store.get('plan-1', 'test_cases')), 'generate');
+});
+
+test('reuses in-flight request for the same plan and target', async () => {
+  const store = createAiDecomposeSessionStore();
+  let callCount = 0;
+  const run = async () => {
+    callCount += 1;
+    return payload;
+  };
+
+  const first = store.start('plan-1', 'dev_tasks', run);
+  const second = store.start('plan-1', 'dev_tasks', run);
+
+  assert.equal(first, second);
+  await Promise.all([first, second]);
+  assert.equal(callCount, 1);
+});

apps/web/lib/ai-decompose-session.ts

@@ -0,0 +1,92 @@
+import type { AgentDecomposeResponse, AgentDecomposeTarget } from '@ftb/shared';
+
+export interface AiDecomposeCompletedPayload {
+  result: AgentDecomposeResponse;
+  dedupeSummary: { removedDevTaskCount: number; removedTestCaseCount: number };
+}
+
+export type AiDecomposeButtonMode = 'generate' | 'generating' | 'view_result' | 'retry';
+
+export type AiDecomposeSessionState =
+  | { status: 'idle' }
+  | { status: 'generating'; startedAt: number; promise: Promise<AiDecomposeCompletedPayload> }
+  | { status: 'completed'; completedAt: number; payload: AiDecomposeCompletedPayload }
+  | { status: 'error'; failedAt: number; error: string };
+
+type Listener = () => void;
+
+export interface AiDecomposeSessionStore {
+  get: (planId: string, target: AgentDecomposeTarget) => AiDecomposeSessionState;
+  start: (
+    planId: string,
+    target: AgentDecomposeTarget,
+    run: () => Promise<AiDecomposeCompletedPayload>,
+  ) => Promise<AiDecomposeCompletedPayload>;
+  markReviewed: (planId: string, target: AgentDecomposeTarget) => void;
+  subscribe: (listener: Listener) => () => void;
+}
+
+function getSessionKey(planId: string, target: AgentDecomposeTarget): string {
+  return `${planId}::${target}`;
+}
+
+function normalizeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error || 'AI 生成失败');
+}
+
+export function createAiDecomposeSessionStore(): AiDecomposeSessionStore {
+  const sessions = new Map<string, AiDecomposeSessionState>();
+  const listeners = new Set<Listener>();
+
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+
+  return {
+    get(planId, target) {
+      return sessions.get(getSessionKey(planId, target)) ?? { status: 'idle' };
+    },
+
+    start(planId, target, run) {
+      const key = getSessionKey(planId, target);
+      const existing = sessions.get(key);
+      if (existing?.status === 'generating') return existing.promise;
+
+      const promise = run().then(
+        (payload) => {
+          sessions.set(key, { status: 'completed', completedAt: Date.now(), payload });
+          notify();
+          return payload;
+        },
+        (error) => {
+          sessions.set(key, { status: 'error', failedAt: Date.now(), error: normalizeError(error) });
+          notify();
+          throw error;
+        },
+      );
+
+      sessions.set(key, { status: 'generating', startedAt: Date.now(), promise });
+      notify();
+      return promise;
+    },
+
+    markReviewed(planId, target) {
+      sessions.delete(getSessionKey(planId, target));
+      notify();
+    },
+
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+export function getAiDecomposeButtonMode(session: AiDecomposeSessionState): AiDecomposeButtonMode {
+  if (session.status === 'generating') return 'generating';
+  if (session.status === 'completed') return 'view_result';
+  if (session.status === 'error') return 'retry';
+  return 'generate';
+}
+
+export const aiDecomposeSessionStore = createAiDecomposeSessionStore();