openmatrix 0.1.49 → 0.1.51

package/dist/orchestrator/smart-question-analyzer.d.ts

@@ -20,24 +20,10 @@ export interface ProjectContext {
     packageManager: 'npm' | 'yarn' | 'pnpm' | 'pip' | 'go-mod' | 'cargo' | 'unknown';
     dependencies: Record<string, string>;
 }
-/**
- * 任务理解
- */
-export interface TaskUnderstanding {
-    taskType: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'unknown';
-    taskTypeLabel: string;
-    scope: string[];
-    scopeLabel: string;
-    complexity: 'simple' | 'medium' | 'complex';
-    complexityLabel: string;
-    estimatedCommits: string;
-    suggestions: string[];
-}
 /**
  * 分析结果
  */
 export interface AnalysisResult {
-    understanding: TaskUnderstanding;
     inferences: QuestionInference[];
     questionsToAsk: string[];
     skippedQuestions: string[];
@@ -65,26 +51,6 @@ export declare class SmartQuestionAnalyzer {
      * 获取项目上下文
      */
     getProjectContext(): Promise<ProjectContext>;
-    /**
-     * 分析任务理解
-     */
-    private analyzeTaskUnderstanding;
-    /**
-     * 检测任务类型
-     */
-    private detectTaskType;
-    /**
-     * 检测影响范围
-     */
-    private detectScope;
-    /**
-     * 检测复杂度
-     */
-    private detectComplexity;
-    /**
-     * 生成建议
-     */
-    private generateSuggestions;
     /**
      * 推断问题答案
      */
@@ -113,8 +79,4 @@ export declare class SmartQuestionAnalyzer {
      * 生成推断摘要
      */
     generateSummary(result: AnalysisResult): string;
-    /**
-     * 生成 Markdown 格式输出
-     */
-    generateMarkdown(result: AnalysisResult): string;
 }

package/dist/orchestrator/smart-question-analyzer.js

@@ -58,11 +58,9 @@ class SmartQuestionAnalyzer {
     async analyze(taskDescription, parsedTask) {
         // 1. 获取项目上下文
         const projectContext = await this.getProjectContext();
-        // 2. 分析任务理解
-        const understanding = this.analyzeTaskUnderstanding(taskDescription, projectContext);
-        // 3. 执行推断
+        // 2. 执行推断
         const inferences = this.inferAnswers(taskDescription, projectContext);
-        // 4. 筛选需要提问的问题
+        // 3. 筛选需要提问的问题
         const questionsToAsk = inferences
             .filter(i => i.confidence === 'low' || !i.inferredAnswer)
             .map(i => i.questionId);
@@ -70,7 +68,6 @@ class SmartQuestionAnalyzer {
             .filter(i => i.confidence !== 'low' && i.inferredAnswer)
             .map(i => i.questionId);
         return {
-            understanding,
             inferences,
             questionsToAsk,
             skippedQuestions,
@@ -163,199 +160,6 @@ class SmartQuestionAnalyzer {
         this.cachedContext = context;
         return context;
     }
-    /**
-     * 分析任务理解
-     */
-    analyzeTaskUnderstanding(taskDescription, context) {
-        const desc = taskDescription.toLowerCase();
-        // 1. 判断任务类型
-        const taskType = this.detectTaskType(desc);
-        // 2. 判断影响范围
-        const scope = this.detectScope(desc, context);
-        // 3. 判断复杂度
-        const complexity = this.detectComplexity(desc, taskType, scope);
-        // 4. 生成建议
-        const suggestions = this.generateSuggestions(taskType, complexity, desc);
-        return {
-            taskType: taskType.type,
-            taskTypeLabel: taskType.label,
-            scope: scope.areas,
-            scopeLabel: scope.label,
-            complexity: complexity.level,
-            complexityLabel: complexity.label,
-            estimatedCommits: complexity.estimatedCommits,
-            suggestions
-        };
-    }
-    /**
-     * 检测任务类型
-     */
-    detectTaskType(desc) {
-        // Bug 修复
-        if (/(fix|bug|修复|hotfix|patch|问题|报错|错误|异常)/i.test(desc)) {
-            return { type: 'bugfix', label: 'Bug 修复' };
-        }
-        // 重构
-        if (/(refactor|重构|优化|improve|改进)/i.test(desc)) {
-            return { type: 'refactor', label: '重构优化' };
-        }
-        // 文档
-        if (/(doc|文档|readme|文档|注释)/i.test(desc)) {
-            return { type: 'docs', label: '文档编写' };
-        }
-        // 测试
-        if (/(test|测试|单元|unit|coverage|覆盖率)/i.test(desc)) {
-            return { type: 'test', label: '测试编写' };
-        }
-        // 配置
-        if (/(config|配置|设置|setup|初始化)/i.test(desc)) {
-            return { type: 'config', label: '配置修改' };
-        }
-        // 新功能 (默认)
-        if (/(implement|add|新功能|实现|开发|feature|添加|创建)/i.test(desc)) {
-            return { type: 'feature', label: '新功能开发' };
-        }
-        return { type: 'unknown', label: '待确认' };
-    }
-    /**
-     * 检测影响范围
-     */
-    detectScope(desc, context) {
-        const areas = [];
-        // 从描述中检测
-        if (/(前端|页面|ui|样式|css|html|react|vue|component)/i.test(desc)) {
-            areas.push('前端');
-        }
-        if (/(后端|api|服务|server|接口|数据库|database)/i.test(desc)) {
-            areas.push('后端');
-        }
-        if (/(cli|命令行|终端|terminal)/i.test(desc)) {
-            areas.push('CLI');
-        }
-        if (/(测试|test|spec)/i.test(desc)) {
-            areas.push('测试');
-        }
-        if (/(文档|doc|readme)/i.test(desc)) {
-            areas.push('文档');
-        }
-        if (/(配置|config)/i.test(desc)) {
-            areas.push('配置');
-        }
-        // 从项目上下文补充
-        if (areas.length === 0) {
-            if (context.hasFrontend)
-                areas.push('前端');
-            if (context.hasBackend)
-                areas.push('后端');
-        }
-        // 默认
-        if (areas.length === 0) {
-            areas.push('代码');
-        }
-        const label = areas.join('、');
-        return { areas, label };
-    }
-    /**
-     * 检测复杂度
-     */
-    detectComplexity(desc, taskType, scope) {
-        // 简单任务关键词
-        const simpleKeywords = /(fix|bug|修复|改|调整|样式|变量名|文案|按钮|颜色|字体)/i;
-        // 复杂任务关键词 - 需要更精确
-        const complexKeywords = /(系统|架构|集成|完整|从零|优化整体|多模块|全栈)/i;
-        const multiScope = scope.areas.length >= 3;
-        // Bug 修复
-        if (taskType.type === 'bugfix') {
-            if (simpleKeywords.test(desc) || desc.length < 50) {
-                return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 1-2 个 commit' };
-        }
-        // 文档、配置
-        if (taskType.type === 'docs' || taskType.type === 'config') {
-            return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-        }
-        // 测试
-        if (taskType.type === 'test') {
-            if (multiScope) {
-                return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-            }
-            return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-        }
-        // 复杂关键词检测
-        if (complexKeywords.test(desc) || multiScope) {
-            return { level: 'complex', label: '复杂', estimatedCommits: '预计 3+ 个 commit' };
-        }
-        // 新功能 - 默认 medium
-        if (taskType.type === 'feature') {
-            // 只有非常简单的单文件修改才判断为 simple
-            if (desc.length < 20 && scope.areas.length === 1 && /(按钮|链接|文案|颜色)/.test(desc)) {
-                return { level: 'simple', label: '简单', estimatedCommits: '预计 1 个 commit' };
-            }
-            if (desc.length > 100 || scope.areas.length >= 2) {
-                return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-        }
-        // 重构 - 默认 medium
-        if (taskType.type === 'refactor') {
-            if (multiScope || /(整体|全部|系统)/.test(desc)) {
-                return { level: 'complex', label: '复杂', estimatedCommits: '预计 3+ 个 commit' };
-            }
-            return { level: 'medium', label: '中等', estimatedCommits: '预计 2-3 个 commit' };
-        }
-        // 默认中等
-        return { level: 'medium', label: '中等', estimatedCommits: '预计 1-2 个 commit' };
-    }
-    /**
-     * 生成建议
-     */
-    generateSuggestions(taskType, complexity, desc) {
-        const suggestions = [];
-        // 复杂任务优先建议头脑风暴
-        if (complexity.level === 'complex') {
-            suggestions.push('建议先头脑风暴，明确需求');
-        }
-        // 根据任务类型建议
-        switch (taskType.type) {
-            case 'bugfix':
-                suggestions.push('直接修复，无需 TDD');
-                suggestions.push('使用 fast 模式');
-                break;
-            case 'feature':
-                if (complexity.level === 'complex') {
-                    suggestions.push('使用 strict 模式保证质量');
-                }
-                else {
-                    suggestions.push('使用 balanced 模式');
-                }
-                break;
-            case 'refactor':
-                suggestions.push('确保测试覆盖');
-                suggestions.push('使用 balanced 模式');
-                break;
-            case 'test':
-                suggestions.push('使用 fast 或 balanced 模式');
-                break;
-            case 'docs':
-                suggestions.push('无需测试');
-                suggestions.push('使用 fast 模式');
-                break;
-            case 'config':
-                suggestions.push('注意配置安全');
-                suggestions.push('使用 fast 模式');
-                break;
-            default:
-                if (complexity.level !== 'complex') {
-                    suggestions.push('根据实际情况选择模式');
-                }
-        }
-        // 确保至少有一个建议
-        if (suggestions.length === 0) {
-            suggestions.push('建议先确认任务需求');
-        }
-        return suggestions;
-    }
     /**
      * 推断问题答案
      */
@@ -584,21 +388,7 @@ class SmartQuestionAnalyzer {
      * 生成推断摘要
      */
     generateSummary(result) {
-        const lines = [];
-        // 任务理解
-        lines.push('🔍 我理解的任务:\n');
-        lines.push(`📋 类型: ${result.understanding.taskTypeLabel}`);
-        lines.push(`📁 范围: ${result.understanding.scopeLabel}`);
-        lines.push(`⚡ 复杂度: ${result.understanding.complexityLabel} (${result.understanding.estimatedCommits})`);
-        // 建议
-        if (result.understanding.suggestions.length > 0) {
-            lines.push('\n💡 建议执行方式:');
-            for (const suggestion of result.understanding.suggestions) {
-                lines.push(`   • ${suggestion}`);
-            }
-        }
-        // 推断结果
-        lines.push('\n📊 配置推断:');
+        const lines = ['📊 AI 推断结果:\n'];
         for (const inference of result.inferences) {
             const icon = inference.confidence === 'high' ? '✅' :
                 inference.confidence === 'medium' ? '🤔' : '❓';
@@ -606,55 +396,15 @@ class SmartQuestionAnalyzer {
                 ? inference.inferredAnswer.join(', ')
                 : inference.inferredAnswer || '待确认';
             lines.push(`${icon} ${inference.questionId}: ${answer}`);
-        }
-        if (result.questionsToAsk.length > 0) {
-            lines.push(`\n❓ 需要确认: ${result.questionsToAsk.join(', ')}`);
-        }
-        else {
-            lines.push('\n✅ 配置已推断，可直接执行');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * 生成 Markdown 格式输出
-     */
-    generateMarkdown(result) {
-        const lines = [];
-        lines.push('## 🔍 我理解的任务\n');
-        lines.push(`| 属性 | 值 |`);
-        lines.push(`|------|-----|`);
-        lines.push(`| 📋 类型 | ${result.understanding.taskTypeLabel} |`);
-        lines.push(`| 📁 范围 | ${result.understanding.scopeLabel} |`);
-        lines.push(`| ⚡ 复杂度 | ${result.understanding.complexityLabel} |`);
-        lines.push(`| ⏱️ 预计 | ${result.understanding.estimatedCommits} |`);
-        // 建议
-        if (result.understanding.suggestions.length > 0) {
-            lines.push('\n## 💡 建议执行方式\n');
-            for (const suggestion of result.understanding.suggestions) {
-                lines.push(`- ${suggestion}`);
+            if (inference.reason) {
+                lines.push(`   └─ ${inference.reason}`);
             }
         }
-        // 推断的配置
-        lines.push('\n## 📊 推荐配置\n');
-        lines.push(`| 配置项 | 推荐值 | 置信度 |`);
-        lines.push(`|--------|--------|--------|`);
-        for (const inference of result.inferences) {
-            const answer = Array.isArray(inference.inferredAnswer)
-                ? inference.inferredAnswer.join(', ')
-                : inference.inferredAnswer || '待确认';
-            const confidenceIcon = inference.confidence === 'high' ? '✅' :
-                inference.confidence === 'medium' ? '🤔' : '❓';
-            lines.push(`| ${inference.questionId} | ${answer} | ${confidenceIcon} |`);
-        }
-        // 需要确认的问题
         if (result.questionsToAsk.length > 0) {
-            lines.push('\n## ❓ 需要确认\n');
-            for (const q of result.questionsToAsk) {
-                lines.push(`- ${q}`);
-            }
+            lines.push(`\n❓ 需要确认的问题: ${result.questionsToAsk.join(', ')}`);
         }
         else {
-            lines.push('\n✅ **所有配置已推断，可直接执行**');
+            lines.push('\n✅ 所有问题已推断，无需额外确认');
         }
         return lines.join('\n');
     }

package/dist/orchestrator/task-parser.d.ts

@@ -1,15 +1,29 @@
 import type { ParsedTask } from '../types/index.js';
-/**
- * TaskParser - 任务解析器
- *
- * 职责：解析用户输入的任务描述，提取结构化信息
- *
- * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
- * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
- */
 export declare class TaskParser {
     parse(content: string): ParsedTask;
     private extractTitle;
     private extractDescription;
     private extractSection;
+    /**
+     * 从纯文本中智能提取 goals
+     *
+     * 策略优先级:
+     * 1. 有序列表 (1. xxx, 2. xxx)
+     * 2. 无序列表 (- xxx, * xxx)
+     * 3. 分号/换行分隔的多行描述
+     * 4. 将标题作为唯一 goal
+     */
+    private extractGoalsFromPlainText;
+    /**
+     * 提取有序列表项
+     */
+    private extractOrderedItems;
+    /**
+     * 提取无序列表项
+     */
+    private extractUnorderedItems;
+    /**
+     * 从文本中提取句子作为 goals
+     */
+    private extractSentences;
 }

package/dist/orchestrator/task-parser.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskParser = void 0;
-/**
- * TaskParser - 任务解析器
- *
- * 职责：解析用户输入的任务描述，提取结构化信息
- *
- * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
- * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
- */
 class TaskParser {
     parse(content) {
         const title = this.extractTitle(content);
@@ -16,53 +8,61 @@ class TaskParser {
         const constraints = this.extractSection(content, '约束');
         const deliverables = this.extractSection(content, '交付物');
         const description = this.extractDescription(content);
+        // Fallback: 当 markdown section 未提取到 goals 时，智能提取
+        const finalGoals = goals.length > 0
+            ? goals
+            : this.extractGoalsFromPlainText(content, title);
+        // Fallback: 当无 deliverables 时，从 goals 推断
+        const finalDeliverables = deliverables.length > 0
+            ? deliverables
+            : finalGoals.map(g => `${g} 的实现`);
         return {
             title,
-            description,
-            goals: [...new Set(goals)], // 去重
-            constraints: [...new Set(constraints)], // 去重
-            deliverables: [...new Set(deliverables)], // 去重
+            description: description || (finalGoals.length > 0 ? finalGoals[0] : title),
+            goals: [...new Set(finalGoals)],
+            constraints: [...new Set(constraints)],
+            deliverables: [...new Set(finalDeliverables)],
             rawContent: content
         };
     }
     extractTitle(content) {
-        // 1. 从第一个 # 标题提取
-        const headerMatch = content.match(/^#\s+(.+)$/m);
-        if (headerMatch) {
-            return headerMatch[1].trim();
-        }
-        // 2. 没有标题，取第一行非空内容（截断到 50 字符）
-        const firstLine = content.split('\n').find(l => l.trim());
-        return firstLine ? firstLine.trim().slice(0, 50) : 'Untitled Task';
+        const match = content.match(/^#\s+(.+)$/m);
+        return match ? match[1].trim() : 'Untitled Task';
     }
     extractDescription(content) {
-        // 移除标题和 sections，获取第一段
-        let desc = content
-            .replace(/^#\s+.+$/m, '')
-            .replace(/^##\s+.+$/gm, '')
-            .replace(/^- .+$/gm, '')
-            .trim();
-        // 获取第一个非空行
+        // Remove title line
+        let desc = content.replace(/^#\s+.+$/m, '').trim();
+        // Remove section headers
+        desc = desc.replace(/^##\s+.+$/gm, '').trim();
+        // Get first non-empty, non-list line as description
         const lines = desc.split('\n').filter(l => l.trim());
-        return lines.length > 0 ? lines[0].trim() : '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip list items, section headers
+            if (/^[-*]\s+/.test(trimmed))
+                continue;
+            if (/^\d+\.\s+/.test(trimmed))
+                continue;
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+        return '';
     }
     extractSection(content, sectionName) {
         const lines = content.split('\n');
         const items = [];
         let inSection = false;
         for (const line of lines) {
-            // 检查是否进入目标 section
             if (line.match(new RegExp(`^##\\s+${sectionName}\\s*$`))) {
                 inSection = true;
                 continue;
             }
-            // 检查是否进入其他 section
             if (line.match(/^##\s+/)) {
                 if (inSection)
                     break;
                 continue;
             }
-            // 提取列表项
             if (inSection) {
                 const itemMatch = line.match(/^-\s+(.+)$/);
                 if (itemMatch) {
@@ -72,5 +72,92 @@ class TaskParser {
         }
         return items;
     }
+    /**
+     * 从纯文本中智能提取 goals
+     *
+     * 策略优先级:
+     * 1. 有序列表 (1. xxx, 2. xxx)
+     * 2. 无序列表 (- xxx, * xxx)
+     * 3. 分号/换行分隔的多行描述
+     * 4. 将标题作为唯一 goal
+     */
+    extractGoalsFromPlainText(content, title) {
+        const goals = [];
+        const cleanContent = content
+            .replace(/^#\s+.+$/m, '') // 去标题
+            .replace(/^##\s+.+$/gm, '') // 去section标题
+            .trim();
+        // 策略1: 有序列表 (1. xxx, 2. xxx, ...)
+        const orderedItems = this.extractOrderedItems(cleanContent);
+        if (orderedItems.length > 0) {
+            return orderedItems;
+        }
+        // 策略2: 无序列表 (- xxx, * xxx)
+        const unorderedItems = this.extractUnorderedItems(cleanContent);
+        if (unorderedItems.length > 0) {
+            return unorderedItems;
+        }
+        // 策略3: 多行文本，按句号/分号拆分为多个 goal
+        const sentences = this.extractSentences(cleanContent);
+        if (sentences.length > 1) {
+            return sentences;
+        }
+        // 策略4: 单个句子作为唯一 goal
+        if (sentences.length === 1 && sentences[0].length > 0) {
+            return sentences;
+        }
+        // 策略5: 将标题作为唯一 goal
+        if (title && title !== 'Untitled Task') {
+            return [title];
+        }
+        return goals;
+    }
+    /**
+     * 提取有序列表项
+     */
+    extractOrderedItems(text) {
+        const items = [];
+        const lines = text.split('\n');
+        for (const line of lines) {
+            const match = line.trim().match(/^\d+[.、)\s]+(.+)$/);
+            if (match) {
+                const item = match[1].trim();
+                if (item.length > 0) {
+                    items.push(item);
+                }
+            }
+        }
+        return items;
+    }
+    /**
+     * 提取无序列表项
+     */
+    extractUnorderedItems(text) {
+        const items = [];
+        const lines = text.split('\n');
+        for (const line of lines) {
+            const match = line.trim().match(/^[-*]\s+(.+)$/);
+            if (match) {
+                const item = match[1].trim();
+                if (item.length > 0) {
+                    items.push(item);
+                }
+            }
+        }
+        return items;
+    }
+    /**
+     * 从文本中提取句子作为 goals
+     */
+    extractSentences(text) {
+        if (!text || text.trim().length === 0)
+            return [];
+        // 按中文句号、英文句号、分号拆分
+        const sentences = text
+            .split(/[。；\n]/)
+            .map(s => s.replace(/[.;]/g, '').trim())
+            .filter(s => s.length > 2); // 过滤太短的片段
+        return sentences;
+    }
 }
 exports.TaskParser = TaskParser;

package/dist/orchestrator/task-planner.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedTask } from '../types/index.js';
+import type { ParsedTask, QualityConfig } from '../types/index.js';
 export interface TaskBreakdown {
     taskId: string;
     title: string;
@@ -17,34 +17,61 @@ export interface UserAnswers {
     testCoverage?: string;
     documentationLevel?: string;
     additionalContext?: Record<string, string>;
+    /** 是否启用 E2E 测试 */
+    e2eTests?: boolean;
+    /** E2E 测试类型 (web/mobile/gui) */
+    e2eType?: 'web' | 'mobile' | 'gui';
+    /** 质量级别 */
+    qualityLevel?: 'fast' | 'balanced' | 'strict';
 }
 /**
  * TaskPlanner - 任务拆解器
  *
- * 1. 按 goals 拆分为多个 coder + tester 任务对
- * 2. goals 为空时退化为 3 任务模式 (planner → coder → tester)
- * 3. 自动注入用户上下文和验收标准
+ * 增强版特性:
+ * 1. 更细粒度的任务拆分 (每个目标拆分为设计+实现+测试)
+ * 2. 测试任务配对 (每个开发任务自动生成对应测试任务)
+ * 3. 验收标准注入 (从用户回答中提取)
+ * 4. 用户上下文注入 (将用户回答注入任务描述)
+ * 5. 依赖关系分析 (自动分析任务间依赖)
+ * 6. 并行执行 (独立任务互不依赖)
+ * 7. 质量级别感知 (根据配置调整测试覆盖率)
  */
 export declare class TaskPlanner {
+    private userAnswers;
+    private taskCounter;
+    constructor(userAnswers?: UserAnswers);
+    /**
+     * 设置用户回答
+     */
+    setUserAnswers(answers: UserAnswers): void;
     /**
      * Break down a parsed task into sub-tasks
      */
-    breakdown(parsedTask: ParsedTask, answers: Record<string, string>): TaskBreakdown[];
+    breakdown(parsedTask: ParsedTask, answers: Record<string, string>, qualityConfig?: QualityConfig, plan?: string): TaskBreakdown[];
+    /**
+     * 判断是否需要设计阶段
+     *
+     * 条件: 多个 goal，或 goal 包含复杂关键词
+     */
+    private needsDesignPhase;
     /**
-     * 按 goals 拆分: 每个 goal 一个 coder + 一个 tester
+     * 获取测试覆盖率目标
      */
-    private breakdownByGoals;
+    private getCoverageTarget;
     /**
-     * 无 goals 时的退化模式: planner → coder → tester
-     * 把 rawContent 整体交给 planner 分析，生成 PLAN.md
-     * coder 基于 PLAN.md 实现
+     * 提取用户上下文
      */
-    private breakdownFallback;
     private extractUserContext;
     private parseArrayAnswer;
+    /**
+     * 构建全局上下文块（注入到每个子任务描述中）
+     */
+    private buildGlobalContext;
     private buildTaskDescription;
     private buildTestDescription;
-    private parseCoverage;
+    private buildE2ETestDescription;
+    private getE2ETypeConfig;
+    private generateUserFlows;
     private generateAcceptanceCriteria;
     private generateTaskId;
     private determinePriority;