mycohive-claw 4.0.0

package/dist/intent-analyzer.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Intent Analyzer 模块
+ * 版本: v4.0.0
+ *
+ * LLM 意图分析，自动路由到对应 Agent。
+ * 核心模块：取消 @xxx/!! 标识，实现自然语言自动路由。
+ */
+import type { WorkspaceLoader } from "./workspace-loader.js";
+export declare enum TaskType {
+    CODE = "code",
+    CODE_REVIEW = "code_review",
+    CODE_DEBUG = "code_debug",
+    ARCHITECTURE = "architecture",
+    DESIGN = "design",
+    DATA_ANALYSIS = "data_analysis",
+    RESEARCH = "research",
+    WRITING = "writing",
+    TRANSLATION = "translation",
+    DEPLOYMENT = "deployment",
+    SECURITY = "security",
+    QA_TESTING = "qa_testing",
+    COORDINATION = "coordination",
+    PLANNING = "planning",
+    QUERY = "query",
+    UNKNOWN = "unknown"
+}
+export declare enum Complexity {
+    SIMPLE = "simple",
+    MEDIUM = "medium",
+    COMPLEX = "complex"
+}
+export declare enum Workflow {
+    EXECUTE = "EXECUTE",
+    PIPELINE = "PIPELINE",
+    PARALLEL = "PARALLEL",
+    ITERATE = "ITERATE",
+    COLLABORATE = "COLLABORATE"
+}
+export interface Intent {
+    task_type: TaskType;
+    task_desc: string;
+    complexity: Complexity;
+    required_agents: string[];
+    workflow: Workflow;
+    acceptance_criteria: string;
+    confidence: number;
+    reasoning: string;
+    suggested_steps: Array<{
+        step: number;
+        agent: string;
+        action: string;
+        task_desc: string;
+    }>;
+}
+export interface ExecutionPlan {
+    intent: Intent;
+    steps: Array<{
+        step: number;
+        agent: string;
+        action: string;
+        task_desc: string;
+    }>;
+    topic_id: string;
+    estimated_steps: number;
+}
+type LLMClient = (prompt: string, context?: Record<string, unknown>) => Promise<Record<string, unknown> | string>;
+export declare class IntentAnalyzer {
+    private llmClient;
+    private workspaceLoader;
+    private useSemanticMatch;
+    private agentCache;
+    private agentCacheExpiry;
+    private static readonly AGENT_CACHE_TTL_MS;
+    setLLMClient(client: LLMClient): void;
+    setWorkspaceLoader(loader: WorkspaceLoader): void;
+    /**
+     * 使用同义词扩展关键词
+     */
+    private expandWithSynonyms;
+    /**
+     * 关键词匹配 - 使用简单计数（避免 TF-IDF 在关键词数量不均衡时产生偏差）
+     * 支持同义词扩展
+     */
+    private keywordMatch;
+    /**
+     * 转义正则特殊字符
+     */
+    private escapeRegex;
+    /**
+     * 简单的语义相似度计算（使用字符 n-gram Jaccard 相似度）
+     * 用于处理表达方式不同但语义相似的情况
+     */
+    private simpleSemanticSimilarity;
+    private detectTaskType;
+    /**
+     * 使用语义相似度找到最佳匹配的任务类型
+     */
+    private findBestSemanticMatch;
+    private detectComplexity;
+    private inferAgents;
+    private inferAgentsFromWorkspace;
+    /**
+     * 获取任务类型对应的 capabilities
+     * 可被子类覆盖或从配置读取
+     */
+    private getCapabilitiesForTaskType;
+    private inferWorkflow;
+    /**
+     * 同步分析（无 LLM 调用，仅规则匹配）
+     * 用于测试和快速判断
+     */
+    analyzeSync(userMessage: string): Intent;
+    private inferAgentsSync;
+    analyze(userMessage: string, context?: Record<string, unknown>): Promise<Intent>;
+    private buildAnalysisPrompt;
+    generateExecutionPlan(intent: Intent, topicId: string): ExecutionPlan;
+}
+export {};
+//# sourceMappingURL=intent-analyzer.d.ts.map

package/dist/intent-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-analyzer.d.ts","sourceRoot":"","sources":["../src/intent-analyzer.ts"],"names":[],"mappings":"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"}

package/dist/intent-analyzer.js

@@ -0,0 +1,563 @@
+/**
+ * Intent Analyzer 模块
+ * 版本: v4.0.0
+ *
+ * LLM 意图分析，自动路由到对应 Agent。
+ * 核心模块：取消 @xxx/!! 标识，实现自然语言自动路由。
+ */
+export var TaskType;
+(function (TaskType) {
+    TaskType["CODE"] = "code";
+    TaskType["CODE_REVIEW"] = "code_review";
+    TaskType["CODE_DEBUG"] = "code_debug";
+    TaskType["ARCHITECTURE"] = "architecture";
+    TaskType["DESIGN"] = "design";
+    TaskType["DATA_ANALYSIS"] = "data_analysis";
+    TaskType["RESEARCH"] = "research";
+    TaskType["WRITING"] = "writing";
+    TaskType["TRANSLATION"] = "translation";
+    TaskType["DEPLOYMENT"] = "deployment";
+    TaskType["SECURITY"] = "security";
+    TaskType["QA_TESTING"] = "qa_testing";
+    TaskType["COORDINATION"] = "coordination";
+    TaskType["PLANNING"] = "planning";
+    TaskType["QUERY"] = "query";
+    TaskType["UNKNOWN"] = "unknown";
+})(TaskType || (TaskType = {}));
+export var Complexity;
+(function (Complexity) {
+    Complexity["SIMPLE"] = "simple";
+    Complexity["MEDIUM"] = "medium";
+    Complexity["COMPLEX"] = "complex";
+})(Complexity || (Complexity = {}));
+export var Workflow;
+(function (Workflow) {
+    Workflow["EXECUTE"] = "EXECUTE";
+    Workflow["PIPELINE"] = "PIPELINE";
+    Workflow["PARALLEL"] = "PARALLEL";
+    Workflow["ITERATE"] = "ITERATE";
+    Workflow["COLLABORATE"] = "COLLABORATE";
+})(Workflow || (Workflow = {}));
+// Prompt 版本控制
+const PROMPT_VERSION = "1.0";
+const TASK_TYPE_KEYWORDS = {
+    [TaskType.CODE]: [
+        "写代码", "编写", "实现", "开发", "coding", "code",
+        "写个", "做个", "创建", "添加", "修改", "更新", "function", "class",
+        "帮我写", "写一个函数", "实现功能", "程序", "script",
+        "写个脚本", "开发个", "做个功能", "新建", "增加功能",
+    ],
+    [TaskType.CODE_REVIEW]: [
+        "审查", "review", "检视", "看看代码", "检查代码",
+        "代码审查", "review code", "review", "审核", "评审",
+        "看看有没有问题", "检查下代码", "review一下",
+    ],
+    [TaskType.CODE_DEBUG]: [
+        "debug", "调试", "修复bug", "报错", "出问题",
+        "错误", "异常", "fix bug", "fix", "bug", "崩溃", "卡死",
+        "报错了", "有bug", "修一下", "哪里错了", "解决",
+    ],
+    [TaskType.ARCHITECTURE]: [
+        "架构", "architecture", "设计方案", "技术选型",
+        "怎么设计", "如何架构", "架构设计", "系统架构", "微服务",
+        "技术架构", "整体设计", "架构方案",
+    ],
+    [TaskType.DESIGN]: [
+        "设计", "UI", "界面", "design", "页面", "组件", "design",
+        "前端", "界面设计", "做界面", "画页面", "写页面",
+        "样式", "布局", "组件设计",
+    ],
+    [TaskType.DATA_ANALYSIS]: [
+        "分析", "analytics", "数据", "统计", "报表",
+        "可视化", "dashboard", "分析", "数据分析", "统计",
+        "数据处理", "数据分析", "报表", "图表",
+    ],
+    [TaskType.RESEARCH]: [
+        "研究", "调研", "research", "调查", "搜索",
+        "查找", "了解一下", "research", "了解一下",
+        "查一下", "搜索", "调研", "研究一下",
+    ],
+    [TaskType.WRITING]: [
+        "写", "写作", "文档", "报告", "撰写",
+        "writing", "文章", "写一个", "写篇", "写个文档",
+        "写文档", "写报告", "写文章", "撰写",
+    ],
+    [TaskType.TRANSLATION]: [
+        "翻译", "translate", "中译英", "英译中", "translate",
+        "翻译成", "英汉", "汉英", "语言转换",
+    ],
+    [TaskType.DEPLOYMENT]: [
+        "部署", "deploy", "发布", "上线", "安装", "配置", "deploy",
+        "发布", "上线", "部署到", "安装", "搭建环境",
+        "跑起来", "启动", "发布应用",
+    ],
+    [TaskType.SECURITY]: [
+        "安全", "security", "漏洞", "渗透", "审计", "security",
+        "安全检查", "漏洞扫描", "渗透测试", "安全审计",
+    ],
+    [TaskType.QA_TESTING]: [
+        "测试", "test", "测试用例", "验证", "QA", "testing",
+        "单元测试", "功能测试", "测试一下", "跑测试",
+        "自动化测试", "测试用例", "验证",
+    ],
+    [TaskType.COORDINATION]: [
+        "协调", "协作", "coordination", "合作", "collaborate",
+        "协作", "配合", "沟通", "协调",
+    ],
+    [TaskType.PLANNING]: [
+        "计划", "规划", "planning", "安排", "排期", "planning",
+        "规划", "计划", "安排", "排期", " Roadmap",
+    ],
+    [TaskType.QUERY]: [
+        "查询", "问问", "想知道", "什么是", "怎么", "如何",
+        "问下", "请问", "问一下", "帮我查", "查一下",
+        "告诉我", "谁能", "哪里", "哪个",
+    ],
+    [TaskType.UNKNOWN]: [],
+};
+/**
+ * 同义词映射表 - 扩展关键词匹配
+ */
+const SYNONYMS = {
+    "写": ["创建", "新建", "添加", "实现"],
+    "代码": ["程序", "脚本", "函数", "逻辑"],
+    "查": ["搜索", "查找", "查询", "检索"],
+    "分析": ["分析", "处理", "统计", "计算"],
+    "测试": ["验证", "检验", "检查", "测"],
+    "部署": ["发布", "上线", "安装", "配置"],
+    "设计": ["规划", "方案", "蓝图"],
+    "错误": ["bug", "异常", "问题", "失败"],
+    "修复": ["解决", "改正", "修", "fix"],
+};
+const COMPLEXITY_KEYWORDS = {
+    [Complexity.SIMPLE]: ["简单", "一个", "单个", "只是", "quick", "easy"],
+    [Complexity.MEDIUM]: ["中等", "几个", "一些", "稍微复杂", "medium"],
+    [Complexity.COMPLEX]: ["复杂", "多个", "全面", "整个", "完整", "系统", "complex"],
+};
+// Agent 能力映射
+const AGENT_CAPABILITIES = {
+    coder: [TaskType.CODE, TaskType.CODE_DEBUG],
+    frontend_dev: [TaskType.CODE, TaskType.DESIGN],
+    backend_dev: [TaskType.CODE, TaskType.DEPLOYMENT],
+    api_dev: [TaskType.CODE],
+    data_engineer: [TaskType.DATA_ANALYSIS],
+    scripter: [TaskType.CODE],
+    researcher: [TaskType.RESEARCH],
+    writer: [TaskType.WRITING],
+    translator: [TaskType.TRANSLATION],
+    reviewer: [TaskType.CODE_REVIEW, TaskType.CODE_DEBUG],
+    qa: [TaskType.QA_TESTING],
+    security: [TaskType.SECURITY],
+    evaluator: [TaskType.QA_TESTING],
+    architect: [TaskType.ARCHITECTURE, TaskType.DESIGN],
+    deployer: [TaskType.DEPLOYMENT],
+    coordinator: [TaskType.COORDINATION, TaskType.PLANNING],
+    planner: [TaskType.PLANNING],
+};
+export class IntentAnalyzer {
+    llmClient = null;
+    workspaceLoader = null;
+    useSemanticMatch = true;
+    // Workspace 缓存（减少重复加载）
+    agentCache = null;
+    agentCacheExpiry = 0;
+    static AGENT_CACHE_TTL_MS = 60000; // 1分钟缓存
+    setLLMClient(client) {
+        this.llmClient = client;
+    }
+    setWorkspaceLoader(loader) {
+        this.workspaceLoader = loader;
+    }
+    /**
+     * 使用同义词扩展关键词
+     */
+    expandWithSynonyms(keywords) {
+        const expanded = new Set(keywords);
+        for (const kw of keywords) {
+            if (SYNONYMS[kw]) {
+                for (const syn of SYNONYMS[kw]) {
+                    expanded.add(syn);
+                }
+            }
+        }
+        return Array.from(expanded);
+    }
+    /**
+     * 关键词匹配 - 使用简单计数（避免 TF-IDF 在关键词数量不均衡时产生偏差）
+     * 支持同义词扩展
+     */
+    keywordMatch(text, keywords) {
+        const textLower = text.toLowerCase();
+        const expandedKeywords = this.expandWithSynonyms(keywords);
+        let score = 0;
+        let matchedCount = 0;
+        for (const kw of expandedKeywords) {
+            const regex = new RegExp(this.escapeRegex(kw.toLowerCase()), "gi");
+            const matches = textLower.match(regex);
+            if (matches) {
+                // 简单计数：匹配次数越多分数越高
+                score += matches.length;
+                matchedCount++;
+            }
+        }
+        // 返回原始分数（不再用 TF-IDF 归一化，因为不同类型的关键词数量差异很大）
+        return score;
+    }
+    /**
+     * 转义正则特殊字符
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    /**
+     * 简单的语义相似度计算（使用字符 n-gram Jaccard 相似度）
+     * 用于处理表达方式不同但语义相似的情况
+     */
+    simpleSemanticSimilarity(text1, text2) {
+        const normalize = (s) => s.toLowerCase().replace(/[^\w\u4e00-\u9fff]/g, "").split("").sort().join("");
+        const getNgrams = (s, n) => {
+            const normalized = normalize(s);
+            const grams = new Set();
+            for (let i = 0; i <= normalized.length - n; i++) {
+                grams.add(normalized.slice(i, i + n));
+            }
+            return grams;
+        };
+        const bigrams1 = getNgrams(text1, 2);
+        const bigrams2 = getNgrams(text2, 2);
+        // Jaccard 相似度
+        let intersection = 0;
+        for (const gram of bigrams1) {
+            if (bigrams2.has(gram))
+                intersection++;
+        }
+        const union = bigrams1.size + bigrams2.size - intersection;
+        return union > 0 ? intersection / union : 0;
+    }
+    detectTaskType(message) {
+        const scores = {};
+        for (const [taskType, keywords] of Object.entries(TASK_TYPE_KEYWORDS)) {
+            const score = this.keywordMatch(message, keywords);
+            if (score > 0) {
+                scores[taskType] = score;
+            }
+        }
+        // 如果没有匹配到，使用语义相似度作为后备
+        if (Object.keys(scores).length === 0 || Object.values(scores).every(s => s === 0)) {
+            const bestMatch = this.findBestSemanticMatch(message);
+            if (bestMatch && bestMatch.similarity > 0.3) {
+                return bestMatch.taskType;
+            }
+            return TaskType.UNKNOWN;
+        }
+        return Object.entries(scores).sort((a, b) => b[1] - a[1])[0][0];
+    }
+    /**
+     * 使用语义相似度找到最佳匹配的任务类型
+     */
+    findBestSemanticMatch(message) {
+        let best = null;
+        for (const [taskType, keywords] of Object.entries(TASK_TYPE_KEYWORDS)) {
+            for (const kw of keywords) {
+                const similarity = this.simpleSemanticSimilarity(message, kw);
+                if (!best || similarity > best.similarity) {
+                    best = { taskType: taskType, similarity };
+                }
+            }
+        }
+        return best;
+    }
+    detectComplexity(message) {
+        for (const [complexity, keywords] of Object.entries(COMPLEXITY_KEYWORDS)) {
+            if (this.keywordMatch(message, keywords) > 0) {
+                return complexity;
+            }
+        }
+        return Complexity.MEDIUM;
+    }
+    async inferAgents(taskType) {
+        // 如果有 workspace loader，使用它的配置
+        if (this.workspaceLoader) {
+            return this.inferAgentsFromWorkspace(taskType);
+        }
+        // 回退到硬编码映射
+        const agents = [];
+        for (const [agent, capabilities] of Object.entries(AGENT_CAPABILITIES)) {
+            if (capabilities.includes(taskType)) {
+                agents.push(agent);
+            }
+        }
+        return agents.length > 0 ? agents : ["coder"];
+    }
+    async inferAgentsFromWorkspace(taskType) {
+        if (!this.workspaceLoader)
+            return ["coder"];
+        const now = Date.now();
+        // 检查缓存
+        if (this.agentCache && now < this.agentCacheExpiry) {
+            const cached = this.agentCache.get(taskType);
+            if (cached)
+                return cached;
+        }
+        try {
+            const allWorkspaces = await this.workspaceLoader.loadAll();
+            const matchingAgents = [];
+            // 从所有 workspace 构建 capability → agents 映射
+            const capabilityToAgents = new Map();
+            for (const [agentId, workspace] of allWorkspaces) {
+                const capabilities = workspace.config.capabilities || [];
+                for (const cap of capabilities) {
+                    if (!capabilityToAgents.has(cap)) {
+                        capabilityToAgents.set(cap, []);
+                    }
+                    capabilityToAgents.get(cap).push(agentId);
+                }
+            }
+            // 获取当前 taskType 对应的 capabilities
+            const taskTypeCapabilities = this.getCapabilitiesForTaskType(taskType);
+            // 查找匹配 agents
+            const agentScores = new Map();
+            for (const [agentId, workspace] of allWorkspaces) {
+                const capabilities = workspace.config.capabilities || [];
+                const score = capabilities.filter((c) => taskTypeCapabilities.some((tc) => c.toLowerCase().includes(tc.toLowerCase()))).length;
+                if (score > 0) {
+                    agentScores.set(agentId, score);
+                }
+            }
+            // 按分数排序
+            const sorted = Array.from(agentScores.entries())
+                .sort((a, b) => b[1] - a[1])
+                .map(([agent]) => agent);
+            if (sorted.length > 0) {
+                // 缓存结果
+                if (!this.agentCache)
+                    this.agentCache = new Map();
+                this.agentCache.set(taskType, sorted);
+                this.agentCacheExpiry = now + IntentAnalyzer.AGENT_CACHE_TTL_MS;
+                return sorted;
+            }
+        }
+        catch (error) {
+            console.warn("[IntentAnalyzer] Workspace inference failed:", error);
+        }
+        return ["coder"];
+    }
+    /**
+     * 获取任务类型对应的 capabilities
+     * 可被子类覆盖或从配置读取
+     */
+    getCapabilitiesForTaskType(taskType) {
+        // 默认映射，可被配置覆盖
+        const DEFAULT_CAPABILITY_MAP = {
+            "code": ["code", "coding", "implementation"],
+            "code_review": ["review", "code_review", "inspection"],
+            "code_debug": ["debug", "fix", "troubleshooting"],
+            "architecture": ["architecture", "design", "system_design"],
+            "design": ["design", "ui", "ux", "interface"],
+            "data_analysis": ["analytics", "data", "analysis", "statistics"],
+            "research": ["research", "investigation", "study"],
+            "writing": ["writing", "documentation", "documentation"],
+            "translation": ["translation", "localization"],
+            "deployment": ["deploy", "deployment", "devops", "release"],
+            "security": ["security", "audit", "vulnerability"],
+            "qa_testing": ["testing", "qa", "quality_assurance", "test"],
+            "coordination": ["coordination", "collaboration", "management"],
+            "planning": ["planning", "strategy", "roadmap"],
+            "query": ["query", "search", "information"],
+        };
+        return DEFAULT_CAPABILITY_MAP[taskType] || [taskType];
+    }
+    inferWorkflow(taskType, complexity, agentCount) {
+        if (complexity === Complexity.SIMPLE || agentCount <= 1) {
+            return Workflow.EXECUTE;
+        }
+        if (taskType === TaskType.CODE_REVIEW) {
+            return Workflow.PIPELINE;
+        }
+        if (complexity === Complexity.COMPLEX && agentCount > 1) {
+            return Workflow.COLLABORATE;
+        }
+        return Workflow.EXECUTE;
+    }
+    /**
+     * 同步分析（无 LLM 调用，仅规则匹配）
+     * 用于测试和快速判断
+     */
+    analyzeSync(userMessage) {
+        const taskType = this.detectTaskType(userMessage);
+        const complexity = this.detectComplexity(userMessage);
+        const requiredAgents = this.inferAgentsSync(taskType);
+        const workflow = this.inferWorkflow(taskType, complexity, requiredAgents.length);
+        return {
+            task_type: taskType,
+            task_desc: userMessage,
+            complexity,
+            required_agents: requiredAgents,
+            workflow,
+            acceptance_criteria: "完成基本功能",
+            confidence: 0.7,
+            reasoning: "Rule-based analysis (sync)",
+            suggested_steps: [],
+        };
+    }
+    inferAgentsSync(taskType) {
+        // 回退到硬编码映射（同步版本）
+        const agents = [];
+        for (const [agent, capabilities] of Object.entries(AGENT_CAPABILITIES)) {
+            if (capabilities.includes(taskType)) {
+                agents.push(agent);
+            }
+        }
+        return agents.length > 0 ? agents : ["coder"];
+    }
+    async analyze(userMessage, context = {}) {
+        const quickTaskType = this.detectTaskType(userMessage);
+        let reasoning = "";
+        let llmIntent = null;
+        if (this.llmClient) {
+            try {
+                const rawResult = await this.llmClient(this.buildAnalysisPrompt(userMessage, context), context);
+                if (typeof rawResult === "string") {
+                    try {
+                        llmIntent = JSON.parse(rawResult);
+                    }
+                    catch {
+                        llmIntent = null;
+                    }
+                }
+                else {
+                    llmIntent = rawResult;
+                }
+                reasoning = llmIntent?.reasoning || "LLM analysis completed";
+            }
+            catch (error) {
+                reasoning = `LLM analysis failed, using rule-based fallback: ${error}`;
+            }
+        }
+        else {
+            reasoning = "Rule-based analysis (no LLM client configured)";
+        }
+        // 合并结果
+        const taskTypeStr = llmIntent?.task_type || quickTaskType;
+        const taskType = Object.values(TaskType).includes(taskTypeStr)
+            ? taskTypeStr
+            : quickTaskType;
+        const complexityStr = llmIntent?.complexity || this.detectComplexity(userMessage);
+        const complexity = Object.values(Complexity).includes(complexityStr)
+            ? complexityStr
+            : this.detectComplexity(userMessage);
+        const requiredAgents = llmIntent?.required_agents || await this.inferAgents(taskType);
+        const workflowStr = llmIntent?.workflow || this.inferWorkflow(taskType, complexity, requiredAgents.length);
+        const workflow = Object.values(Workflow).includes(workflowStr)
+            ? workflowStr
+            : this.inferWorkflow(taskType, complexity, requiredAgents.length);
+        const acceptanceCriteria = llmIntent?.acceptance_criteria || "完成基本功能";
+        const confidence = llmIntent?.confidence || 0.7;
+        const suggestedSteps = llmIntent?.suggested_steps || [];
+        return {
+            task_type: taskType,
+            task_desc: userMessage,
+            complexity,
+            required_agents: requiredAgents,
+            workflow,
+            acceptance_criteria: acceptanceCriteria,
+            confidence,
+            reasoning,
+            suggested_steps: suggestedSteps,
+        };
+    }
+    buildAnalysisPrompt(userMessage, context) {
+        return `[PROMPT_VERSION=${PROMPT_VERSION}] 分析用户消息，提取以下信息（JSON 格式）：
+
+1. task_type: 任务类型
+   可选值: code, code_review, code_debug, architecture, design, data_analysis,
+           research, writing, translation, deployment, security, qa_testing,
+           coordination, planning, query, unknown
+
+2. complexity: 复杂度
+   可选值: simple, medium, complex
+
+3. required_agents: 需要参与的 Agent 列表
+   可选: coder, frontend_dev, backend_dev, api_dev, data_engineer,
+         scripter, researcher, writer, translator, reviewer, qa,
+         security, evaluator, architect, deployer, coordinator, planner
+
+4. workflow: 工作流类型
+   可选值: EXECUTE (单步执行), PIPELINE (流水线), PARALLEL (并行),
+           ITERATE (迭代), COLLABORATE (协作)
+
+5. acceptance_criteria: 验收标准（中文描述）
+
+6. confidence: 置信度 0-1
+
+7. reasoning: 分析过程说明
+
+8. suggested_steps: 建议执行步骤列表，每步包含 step, agent, action, task_desc
+
+用户消息: ${userMessage}
+
+上下文: ${JSON.stringify(context, null, 2)}
+
+请只返回 JSON，不要有其他文字。`;
+    }
+    generateExecutionPlan(intent, topicId) {
+        const steps = [];
+        switch (intent.workflow) {
+            case Workflow.EXECUTE:
+                steps.push({
+                    step: 1,
+                    agent: intent.required_agents[0] || "coder",
+                    action: "execute",
+                    task_desc: intent.task_desc,
+                });
+                break;
+            case Workflow.PIPELINE:
+                for (let i = 0; i < intent.required_agents.length; i++) {
+                    steps.push({
+                        step: i + 1,
+                        agent: intent.required_agents[i],
+                        action: "execute",
+                        task_desc: i === 0 ? intent.task_desc : "处理来自上一步的结果",
+                    });
+                }
+                break;
+            case Workflow.PARALLEL:
+                for (let i = 0; i < intent.required_agents.length; i++) {
+                    steps.push({
+                        step: i + 1,
+                        agent: intent.required_agents[i],
+                        action: "parallel_execute",
+                        task_desc: intent.task_desc,
+                    });
+                }
+                break;
+            case Workflow.ITERATE:
+                for (let i = 0; i < Math.min(intent.required_agents.length * 2, 6); i++) {
+                    steps.push({
+                        step: i + 1,
+                        agent: intent.required_agents[i % intent.required_agents.length],
+                        action: "iterate",
+                        task_desc: `迭代步骤 ${i + 1}`,
+                    });
+                }
+                break;
+            case Workflow.COLLABORATE:
+                for (let i = 0; i < intent.required_agents.length; i++) {
+                    steps.push({
+                        step: i + 1,
+                        agent: intent.required_agents[i],
+                        action: "discuss",
+                        task_desc: `发表意见: ${intent.task_desc.slice(0, 50)}...`,
+                    });
+                }
+                break;
+        }
+        return {
+            intent,
+            steps,
+            topic_id: topicId,
+            estimated_steps: steps.length,
+        };
+    }
+}
+//# sourceMappingURL=intent-analyzer.js.map