@codewalla_india/openspec 1.3.2 → 1.3.4

package/dist/comprehension-quiz/providers/anthropic.js

@@ -35,19 +35,35 @@ export class AnthropicProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     async generateQuestions(artifactContent, questionCount, artifactType) {
-        // TODO: Implement Anthropic API call
-        // For now, return placeholder questions
         const questions = [];
         for (let i = 0; i < questionCount; i++) {
-            questions.push({
-                text: `Sample question ${i + 1} for ${artifactType}`,
-                options: ['Option A', 'Option B', 'Option C'],
-                correctOption: 0,
-                artifactSource: artifactType,
-            });
+            const q = await this.generateSingleQuestion(artifactContent, artifactType, i, questionCount, questions.map((q) => q.text));
+            questions.push(q);
         }
-        this.validateQuestions(questions);
         return questions;
     }
+    async generateSingleQuestion(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts) {
+        const { system, user } = this.buildSingleQuestionPrompt(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts);
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': this.config.apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.config.model ?? 'claude-3-opus-20240229',
+                max_tokens: 512,
+                system,
+                messages: [{ role: 'user', content: user }],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API error ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        const raw = data.content.find((b) => b.type === 'text')?.text ?? '';
+        return this.parseSingleQuestionResponse(raw, artifactType);
+    }
 }
 //# sourceMappingURL=anthropic.js.map

package/dist/comprehension-quiz/providers/interface.d.ts

@@ -37,23 +37,62 @@ export declare abstract class BaseProvider implements LLMProvider {
      * @returns Array of generated questions
      */
     abstract generateQuestions(artifactContent: string, questionCount: number, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Promise<Question[]>;
+    /**
+     * Generate a single question on-demand.
+     * Subclasses MUST call buildSingleQuestionPrompt() to get the messages and
+     * parseSingleQuestionResponse() to parse the LLM reply. This guarantees the
+     * correct-answer index never leaks into stdout or conversational context.
+     */
+    abstract generateSingleQuestion(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): Promise<Question>;
     /**
      * Validate provider configuration
      * @throws Error if configuration is invalid
      */
     abstract validateConfig(): void;
+    /**
+     * Build the system + user messages for single-question generation.
+     *
+     * Contract:
+     *   - System message explicitly forbids listing multiple questions.
+     *   - User message asks for exactly one question (question N of total).
+     *   - Response format is strict JSON only — no prose, no explanation, no answer label.
+     *   - The correct answer index (correctOption) is returned as a number 0-2; its
+     *     meaning is never explained in the response so the LLM cannot read it back.
+     *
+     * @returns { system, user } message pair ready to send to the LLM API
+     */
+    protected buildSingleQuestionPrompt(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): {
+        system: string;
+        user: string;
+    };
+    /**
+     * Parse the raw LLM text response into a Question object.
+     * Strips markdown fences if present, then JSON-parses and validates.
+     *
+     * @param rawResponse - Raw text returned by the LLM API
+     * @param artifactType - Expected artifact source (used as fallback)
+     * @returns Validated Question object
+     * @throws Error if the response cannot be parsed or fails validation
+     */
+    protected parseSingleQuestionResponse(rawResponse: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Question;
     /**
      * Validate generated questions before returning
      *
      * Ensures all questions have:
      * - Non-empty text
-     - Exactly 3 options
-     - Valid correct option index (0-2)
-     - Valid artifact source
+     * - Exactly 3 options
+     * - Valid correct option index (0-2)
+     * - Valid artifact source
      *
      * @param questions - Questions to validate
      * @throws Error if any question is invalid
      */
     protected validateQuestions(questions: Question[]): void;
+    /**
+     * Validate a single question object.
+     * @param question - Question to validate
+     * @throws Error if invalid
+     */
+    protected validateQuestion(question: Question): void;
 }
 //# sourceMappingURL=interface.d.ts.map

package/dist/comprehension-quiz/providers/interface.js

@@ -31,32 +31,119 @@ export class BaseProvider {
         this.config = config;
         this.validateConfig();
     }
+    /**
+     * Build the system + user messages for single-question generation.
+     *
+     * Contract:
+     *   - System message explicitly forbids listing multiple questions.
+     *   - User message asks for exactly one question (question N of total).
+     *   - Response format is strict JSON only — no prose, no explanation, no answer label.
+     *   - The correct answer index (correctOption) is returned as a number 0-2; its
+     *     meaning is never explained in the response so the LLM cannot read it back.
+     *
+     * @returns { system, user } message pair ready to send to the LLM API
+     */
+    buildSingleQuestionPrompt(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts) {
+        const previousBlock = previousQuestionTexts.length > 0
+            ? `\n\nAlready asked questions (do NOT repeat these):\n${previousQuestionTexts.map((t, i) => `${i + 1}. ${t}`).join('\n')}`
+            : '';
+        const system = [
+            'You are a quiz question generator for a software change review system.',
+            'STRICT RULES — violating any rule causes system failure:',
+            '  1. Output EXACTLY ONE question. Never output a list, array, or multiple questions.',
+            '  2. Output ONLY valid JSON matching the schema below. No prose before or after.',
+            '  3. Do NOT include the word "Answer", "Correct", or any hint about which option is right.',
+            '  4. Do NOT explain the options. Do NOT add notes, caveats, or additional text.',
+            '  5. The "correctOption" field is an opaque integer (0, 1, or 2). Do not label it.',
+            '',
+            'Response schema (output this JSON and nothing else):',
+            '{',
+            '  "text": "<question text>",',
+            '  "options": ["<option 1>", "<option 2>", "<option 3>"],',
+            '  "correctOption": <0|1|2>,',
+            '  "artifactSource": "<proposal|design|specs|plan|tasks>"',
+            '}',
+        ].join('\n');
+        const user = [
+            `Generate question ${questionIndex + 1} of ${totalQuestions} for the "${artifactType}" artifact.`,
+            'The question must require reading the artifact to answer correctly.',
+            'Distractors must be plausible but wrong based on artifact content.',
+            previousBlock,
+            '',
+            `Artifact content:\n---\n${artifactContent}\n---`,
+        ].join('\n');
+        return { system, user };
+    }
+    /**
+     * Parse the raw LLM text response into a Question object.
+     * Strips markdown fences if present, then JSON-parses and validates.
+     *
+     * @param rawResponse - Raw text returned by the LLM API
+     * @param artifactType - Expected artifact source (used as fallback)
+     * @returns Validated Question object
+     * @throws Error if the response cannot be parsed or fails validation
+     */
+    parseSingleQuestionResponse(rawResponse, artifactType) {
+        let text = rawResponse.trim();
+        // Strip markdown code fences if present
+        text = text.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new Error(`LLM returned invalid JSON for single question: ${rawResponse.slice(0, 200)}`);
+        }
+        const q = parsed;
+        if (typeof q['text'] !== 'string' ||
+            !Array.isArray(q['options']) ||
+            typeof q['correctOption'] !== 'number' ||
+            typeof q['artifactSource'] !== 'string') {
+            throw new Error(`LLM response missing required fields: ${JSON.stringify(q)}`);
+        }
+        const question = {
+            text: q['text'],
+            options: q['options'],
+            correctOption: q['correctOption'],
+            artifactSource: q['artifactSource'] ?? artifactType,
+        };
+        this.validateQuestion(question);
+        return question;
+    }
     /**
      * Validate generated questions before returning
      *
      * Ensures all questions have:
      * - Non-empty text
-     - Exactly 3 options
-     - Valid correct option index (0-2)
-     - Valid artifact source
+     * - Exactly 3 options
+     * - Valid correct option index (0-2)
+     * - Valid artifact source
      *
      * @param questions - Questions to validate
      * @throws Error if any question is invalid
      */
     validateQuestions(questions) {
         for (const question of questions) {
-            if (!question.text || question.text.trim().length === 0) {
-                throw new Error('Question text cannot be empty');
-            }
-            if (question.options.length !== 3) {
-                throw new Error('Each question must have exactly 3 options');
-            }
-            if (question.correctOption < 0 || question.correctOption > 2) {
-                throw new Error('Correct option index must be 0, 1, or 2');
-            }
-            if (!['proposal', 'design', 'specs', 'plan', 'tasks'].includes(question.artifactSource)) {
-                throw new Error('Invalid artifact source');
-            }
+            this.validateQuestion(question);
+        }
+    }
+    /**
+     * Validate a single question object.
+     * @param question - Question to validate
+     * @throws Error if invalid
+     */
+    validateQuestion(question) {
+        if (!question.text || question.text.trim().length === 0) {
+            throw new Error('Question text cannot be empty');
+        }
+        if (question.options.length !== 3) {
+            throw new Error('Each question must have exactly 3 options');
+        }
+        if (question.correctOption < 0 || question.correctOption > 2) {
+            throw new Error('Correct option index must be 0, 1, or 2');
+        }
+        if (!['proposal', 'design', 'specs', 'plan', 'tasks'].includes(question.artifactSource)) {
+            throw new Error('Invalid artifact source');
         }
     }
 }

package/dist/comprehension-quiz/providers/local.d.ts

@@ -30,5 +30,6 @@ export declare class LocalProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     generateQuestions(artifactContent: string, questionCount: number, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Promise<Question[]>;
+    generateSingleQuestion(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): Promise<Question>;
 }
 //# sourceMappingURL=local.d.ts.map

package/dist/comprehension-quiz/providers/local.js

@@ -35,19 +35,35 @@ export class LocalProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     async generateQuestions(artifactContent, questionCount, artifactType) {
-        // TODO: Implement local model inference
-        // For now, return placeholder questions
         const questions = [];
         for (let i = 0; i < questionCount; i++) {
-            questions.push({
-                text: `Sample question ${i + 1} for ${artifactType}`,
-                options: ['Option A', 'Option B', 'Option C'],
-                correctOption: 0,
-                artifactSource: artifactType,
-            });
+            const q = await this.generateSingleQuestion(artifactContent, artifactType, i, questionCount, questions.map((q) => q.text));
+            questions.push(q);
         }
-        this.validateQuestions(questions);
         return questions;
     }
+    async generateSingleQuestion(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts) {
+        const { system, user } = this.buildSingleQuestionPrompt(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts);
+        const endpoint = this.config.endpoint ?? 'http://localhost:11434';
+        const response = await fetch(`${endpoint}/api/chat`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                model: this.config.model,
+                stream: false,
+                format: 'json',
+                messages: [
+                    { role: 'system', content: system },
+                    { role: 'user', content: user },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Local model API error ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        const raw = data.message?.content ?? '';
+        return this.parseSingleQuestionResponse(raw, artifactType);
+    }
 }
 //# sourceMappingURL=local.js.map

package/dist/comprehension-quiz/providers/ollama.d.ts

@@ -30,5 +30,6 @@ export declare class OllamaProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     generateQuestions(artifactContent: string, questionCount: number, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Promise<Question[]>;
+    generateSingleQuestion(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): Promise<Question>;
 }
 //# sourceMappingURL=ollama.d.ts.map

package/dist/comprehension-quiz/providers/ollama.js

@@ -35,19 +35,35 @@ export class OllamaProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     async generateQuestions(artifactContent, questionCount, artifactType) {
-        // TODO: Implement Ollama API call
-        // For now, return placeholder questions
         const questions = [];
         for (let i = 0; i < questionCount; i++) {
-            questions.push({
-                text: `Sample question ${i + 1} for ${artifactType}`,
-                options: ['Option A', 'Option B', 'Option C'],
-                correctOption: 0,
-                artifactSource: artifactType,
-            });
+            const q = await this.generateSingleQuestion(artifactContent, artifactType, i, questionCount, questions.map((q) => q.text));
+            questions.push(q);
         }
-        this.validateQuestions(questions);
         return questions;
     }
+    async generateSingleQuestion(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts) {
+        const { system, user } = this.buildSingleQuestionPrompt(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts);
+        const baseUrl = this.config.endpoint ?? 'http://localhost:11434';
+        const response = await fetch(`${baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                model: this.config.model ?? 'llama2',
+                stream: false,
+                format: 'json',
+                messages: [
+                    { role: 'system', content: system },
+                    { role: 'user', content: user },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        const raw = data.message?.content ?? '';
+        return this.parseSingleQuestionResponse(raw, artifactType);
+    }
 }
 //# sourceMappingURL=ollama.js.map

package/dist/comprehension-quiz/providers/openai.d.ts

@@ -30,5 +30,6 @@ export declare class OpenAIProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     generateQuestions(artifactContent: string, questionCount: number, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Promise<Question[]>;
+    generateSingleQuestion(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): Promise<Question>;
 }
 //# sourceMappingURL=openai.d.ts.map

package/dist/comprehension-quiz/providers/openai.js

@@ -35,19 +35,38 @@ export class OpenAIProvider extends BaseProvider {
      * @returns Array of generated questions
      */
     async generateQuestions(artifactContent, questionCount, artifactType) {
-        // TODO: Implement OpenAI API call
-        // For now, return placeholder questions
         const questions = [];
         for (let i = 0; i < questionCount; i++) {
-            questions.push({
-                text: `Sample question ${i + 1} for ${artifactType}`,
-                options: ['Option A', 'Option B', 'Option C'],
-                correctOption: 0,
-                artifactSource: artifactType,
-            });
+            const q = await this.generateSingleQuestion(artifactContent, artifactType, i, questionCount, questions.map((q) => q.text));
+            questions.push(q);
         }
-        this.validateQuestions(questions);
         return questions;
     }
+    async generateSingleQuestion(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts) {
+        const { system, user } = this.buildSingleQuestionPrompt(artifactContent, artifactType, questionIndex, totalQuestions, previousQuestionTexts);
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.config.apiKey}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.config.model ?? 'gpt-4',
+                max_tokens: 512,
+                temperature: 0.7,
+                response_format: { type: 'json_object' },
+                messages: [
+                    { role: 'system', content: system },
+                    { role: 'user', content: user },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI API error ${response.status}: ${await response.text()}`);
+        }
+        const data = (await response.json());
+        const raw = data.choices[0]?.message?.content ?? '';
+        return this.parseSingleQuestionResponse(raw, artifactType);
+    }
 }
 //# sourceMappingURL=openai.js.map

package/dist/comprehension-quiz/question-generator.d.ts

@@ -49,10 +49,58 @@ export declare function calculateQuestionAllocation(totalQuestions: number, arti
  */
 export declare function generateQuestionsForArtifact(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionCount: number, provider: LLMProvider): Promise<Question[]>;
 /**
- * Generate complete quiz question set for all artifacts
+ * On-demand question stream for the quiz executor.
  *
- * Reads all artifact files, calculates question allocation, and generates
- * questions for each artifact type using the provided or fallback LLM provider.
+ * This class resolves the artifact contents and allocation plan upfront, but
+ * NEVER pre-generates questions. Each call to `next()` fetches exactly ONE
+ * question from the LLM — only after the previous question has been answered.
+ *
+ * This enforces FR-10: questions are fetched on-demand, never pre-generated.
+ * The correct answer (correctOption) is held in process memory; it is never
+ * written to stdout, disk, or any external surface.
+ */
+export declare class QuizQuestionStream {
+    private provider;
+    private plan;
+    private totalQuestions;
+    private fetchedCount;
+    private askedTexts;
+    private constructor();
+    /**
+     * Create and initialise a QuizQuestionStream.
+     * Reads artifact files and builds the question plan, but does NOT generate any questions.
+     *
+     * @param artifactPaths - Object mapping artifact types to file paths
+     * @param totalQuestions - Total number of questions the quiz will ask
+     * @param provider - LLM provider (optional, uses fallback if not provided)
+     */
+    static create(artifactPaths: {
+        proposal?: string;
+        design?: string;
+        specs?: string;
+        plan?: string;
+        tasks?: string;
+    }, totalQuestions: number, provider?: LLMProvider): Promise<QuizQuestionStream>;
+    /** Total number of questions this quiz will ask. */
+    get total(): number;
+    /** Whether there are more questions to fetch. */
+    get hasNext(): boolean;
+    /**
+     * Fetch the next question from the LLM.
+     * MUST only be called after the user has answered the current question.
+     * Only one question is held in memory at a time; this method discards the
+     * previous question before fetching the next.
+     *
+     * @returns The next Question, or null if all questions have been asked.
+     */
+    next(): Promise<Question | null>;
+}
+/**
+ * Generate complete quiz question set for all artifacts.
+ *
+ * NOTE: This function pre-generates all questions and should only be used for
+ * non-interactive contexts (e.g. testing, pass recording). During live quiz
+ * execution use QuizQuestionStream.create() instead.
  *
  * @param artifactPaths - Object mapping artifact types to file paths
  * @param totalQuestions - Total number of questions to generate

package/dist/comprehension-quiz/question-generator.js

@@ -97,10 +97,93 @@ export async function generateQuestionsForArtifact(artifactContent, artifactType
     return provider.generateQuestions(artifactContent, questionCount, artifactType);
 }
 /**
- * Generate complete quiz question set for all artifacts
+ * On-demand question stream for the quiz executor.
  *
- * Reads all artifact files, calculates question allocation, and generates
- * questions for each artifact type using the provided or fallback LLM provider.
+ * This class resolves the artifact contents and allocation plan upfront, but
+ * NEVER pre-generates questions. Each call to `next()` fetches exactly ONE
+ * question from the LLM — only after the previous question has been answered.
+ *
+ * This enforces FR-10: questions are fetched on-demand, never pre-generated.
+ * The correct answer (correctOption) is held in process memory; it is never
+ * written to stdout, disk, or any external surface.
+ */
+export class QuizQuestionStream {
+    provider;
+    plan = [];
+    totalQuestions = 0;
+    fetchedCount = 0;
+    askedTexts = [];
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Create and initialise a QuizQuestionStream.
+     * Reads artifact files and builds the question plan, but does NOT generate any questions.
+     *
+     * @param artifactPaths - Object mapping artifact types to file paths
+     * @param totalQuestions - Total number of questions the quiz will ask
+     * @param provider - LLM provider (optional, uses fallback if not provided)
+     */
+    static async create(artifactPaths, totalQuestions, provider) {
+        const llmProvider = provider ?? (await createProviderWithFallback());
+        const stream = new QuizQuestionStream(llmProvider);
+        // Read artifact contents
+        const artifactContents = {};
+        const artifactSizes = { proposal: 0, design: 0, specs: 0, plan: 0, tasks: 0 };
+        for (const [artifactType, filePath] of Object.entries(artifactPaths)) {
+            if (filePath) {
+                const content = await readArtifactContent(filePath);
+                artifactContents[artifactType] = content;
+                artifactSizes[artifactType] = content.length;
+            }
+        }
+        // Build flat ordered plan: [artifactType, content] pairs for each question slot
+        const allocation = calculateQuestionAllocation(totalQuestions, artifactSizes);
+        for (const [artifactType, count] of Object.entries(allocation)) {
+            if (count > 0 && artifactContents[artifactType]) {
+                for (let i = 0; i < count; i++) {
+                    stream.plan.push({
+                        artifactType: artifactType,
+                        content: artifactContents[artifactType],
+                    });
+                }
+            }
+        }
+        stream.totalQuestions = stream.plan.length;
+        return stream;
+    }
+    /** Total number of questions this quiz will ask. */
+    get total() {
+        return this.totalQuestions;
+    }
+    /** Whether there are more questions to fetch. */
+    get hasNext() {
+        return this.fetchedCount < this.totalQuestions;
+    }
+    /**
+     * Fetch the next question from the LLM.
+     * MUST only be called after the user has answered the current question.
+     * Only one question is held in memory at a time; this method discards the
+     * previous question before fetching the next.
+     *
+     * @returns The next Question, or null if all questions have been asked.
+     */
+    async next() {
+        if (!this.hasNext)
+            return null;
+        const slot = this.plan[this.fetchedCount];
+        const question = await this.provider.generateSingleQuestion(slot.content, slot.artifactType, this.fetchedCount, this.totalQuestions, this.askedTexts);
+        this.fetchedCount += 1;
+        this.askedTexts.push(question.text);
+        return question;
+    }
+}
+/**
+ * Generate complete quiz question set for all artifacts.
+ *
+ * NOTE: This function pre-generates all questions and should only be used for
+ * non-interactive contexts (e.g. testing, pass recording). During live quiz
+ * execution use QuizQuestionStream.create() instead.
  *
  * @param artifactPaths - Object mapping artifact types to file paths
  * @param totalQuestions - Total number of questions to generate
@@ -108,33 +191,12 @@ export async function generateQuestionsForArtifact(artifactContent, artifactType
  * @returns Array of all generated questions
  */
 export async function generateQuizQuestions(artifactPaths, totalQuestions, provider) {
-    // Use fallback provider if not provided
-    const llmProvider = provider || await createProviderWithFallback();
-    // Read all artifact contents and calculate sizes
-    const artifactContents = {};
-    const artifactSizes = {
-        proposal: 0,
-        design: 0,
-        specs: 0,
-        plan: 0,
-        tasks: 0,
-    };
-    for (const [artifactType, filePath] of Object.entries(artifactPaths)) {
-        if (filePath) {
-            const content = await readArtifactContent(filePath);
-            artifactContents[artifactType] = content;
-            artifactSizes[artifactType] = content.length;
-        }
-    }
-    // Calculate question allocation
-    const allocation = calculateQuestionAllocation(totalQuestions, artifactSizes);
-    // Generate questions for each artifact type
+    const stream = await QuizQuestionStream.create(artifactPaths, totalQuestions, provider);
     const allQuestions = [];
-    for (const [artifactType, count] of Object.entries(allocation)) {
-        if (count > 0 && artifactContents[artifactType]) {
-            const questions = await generateQuestionsForArtifact(artifactContents[artifactType], artifactType, count, llmProvider);
-            allQuestions.push(...questions);
-        }
+    while (stream.hasNext) {
+        const q = await stream.next();
+        if (q)
+            allQuestions.push(q);
     }
     return allQuestions;
 }