quantumbyte 把意图变成可验证应用

  32  export async function POST(req: NextRequest) {
  33    const body = await req.json().catch(() => null);
  34    const prompt = typeof body?.prompt === 'string' ? body.prompt.trim() : '';
  35    if (!prompt) {
  36      return NextResponse.json({ error: 'prompt is required' }, { status: 400 });
  37    }
  38  
  39    const title = prompt.length > 48 ? `${prompt.slice(0, 48)}…` : prompt;
  40    const project = await prisma.project.create({
  41      data: {
  42        id: ulid(),
  43        prompt,
  44        title,
  45        generationStatus: 'DRAFT',
  46        // Seed the prompt as the first chat turn (PENDING) so the blueprint
  47        // chat renders it and the orchestrator triggers the agent immediately.
  48        chatMessages: {
  49          create: {
  50            id: ulid(),
  51            role: 'USER',
  52            content: prompt,
  53            status: 'PENDING',
  54          },
  55        },
  56      },
  57    });
  58  
  59    return NextResponse.json(project, { status: 201 });
  60  }

  48    const project = await prisma.project.findUnique({ where: { id } });
  49    if (!project) {
  50      return NextResponse.json({ error: 'project not found' }, { status: 404 });
  51    }
  52  
  53    // Persist the user turn as PENDING and stop. The orchestrator assigns it to a
  54    // worker; the worker (Claude Agent SDK, warm session) runs the turn and writes
  55    // the ASSISTANT reply + flips this row to COMPLETED/FAILED (RFC 0003). The web
  56    // app never runs the agent — the client polls the GET endpoint for the result.
  57    const message = await prisma.chatMessage.create({
  58      data: {
  59        id: ulid(),
  60        projectId: id,
  61        role: 'USER',
  62        content,
  63        status: 'PENDING',
  64      },
  65    });
  66  
  67    return NextResponse.json({ message }, { status: 201 });
  68  }

  41        const tick = async (): Promise<boolean> => {
  42          // Also tail the Project (title/desc/logo) + its assets so product edits
  43          // made by the worker's qb-designer tools surface live — the worker bumps
  44          // Project.updatedAt / inserts Asset rows, and this snapshot picks it up.
  45          // Also tail the harness tables + harnessRunning flag so pass-3 verdicts and
  46          // the running indicator stream over this same connection (browsers cap ~6
  47          // per origin, so the harness UI shares the chat stream instead of opening
  48          // its own). The worker runs the harness right after the turn settles, so
  49          // the in-flight condition below also keys off harnessRunning to keep this
  50          // connection open across that hand-off.
  51          const [messages, project, assets, requirements] = await Promise.all([
  52            prisma.chatMessage.findMany({
  53              where: { projectId: id },
  54              orderBy: { createdAt: 'asc' },
  55            }),
  56            prisma.project.findUnique({
  57              where: { id },
  58              select: {
  59                title: true,
  60                desc: true,
  61                logo: true,
  62                status: true,
  63                updatedAt: true,
  64                harnessRunning: true,
  65              },
  66            }),
  67            prisma.asset.findMany({
  68              where: { projectId: id },
  69              orderBy: { createdAt: 'asc' },
  70            }),
  71            prisma.harnessRequirement.findMany({
  72              where: { projectId: id },
  73              include: { result: true },
  74              orderBy: { createdAt: 'asc' },
  75            }),
  76          ]);
  77          const harness = {
  78            requirements: requirements.map(serializeRequirement),
  79            results: requirements
  80              .map((r) => r.result)
  81              .filter((r) => r !== null)
  82              .map(serializeResult),
  83            is_running: project?.harnessRunning ?? false,
  84          };
  85          const payload = { messages, project, assets, harness };
  86          const snapshot = JSON.stringify(payload);
  87          if (snapshot !== lastSnapshot) {
  88            lastSnapshot = snapshot;
  89            send(snapshot);
  90            lastKeepalive = Date.now();
  91          } else if (Date.now() - lastKeepalive > KEEPALIVE_MS) {
  92            controller.enqueue(encoder.encode(': keepalive\n\n'));
  93            lastKeepalive = Date.now();
  94          }
  95  
  96          const inFlight =
  97            messages.some((m) => m.status === 'PENDING' || m.status === 'PROCESSING') ||
  98            (project?.harnessRunning ?? false);
  99          return inFlight;
 100        };

  38  describe('serializeRequirement', () => {
  39    it('lowercases type and severity and keeps the rest verbatim', () => {
  40      expect(serializeRequirement(requirement())).toEqual({
  41        id: 'req_1',
  42        excerpt: 'must send a receipt email',
  43        description: 'A receipt email is sent after checkout',
  44        type: 'functional',
  45        severity: 'blocker',
  46        locked: false,
  47      });
  48    });
  49  
  50    it('preserves the locked flag', () => {
  51      expect(serializeRequirement(requirement({ locked: true })).locked).toBe(
  52        true,
  53      );
  54    });
  55  });
  56  
  57  describe('serializeResult', () => {
  58    it('maps camelCase fields to the snake_case wire format', () => {
  59      expect(serializeResult(result())).toEqual({
  60        requirement_id: 'req_1',
  61        result: 'PASS',
  62        evidence: 'checkout_test.ts asserts the email',
  63        run_status: 'DONE',
  64        last_verified_sha: 'abc123',
  65        watched_paths: ['src/checkout.ts'],
  66        run_at: '2026-07-14T12:00:00.000Z',
  67        is_stale: false,
  68      });
  69    });
  70  
  71    it('emits null run_at when runAt is null', () => {
  72      expect(serializeResult(result({ runAt: null })).run_at).toBeNull();
  73    });