progmune-runtime 2.0.0

package/dist/p0_ssg_demo.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ssg_validator_1 = require("./ssg-validator");
+const authProtocol = [
+    {
+        function: 'verify_password',
+        protocol: {
+            pre_states: ['UNAUTHENTICATED'],
+            post_states: ['AUTHENTICATED'],
+        }
+    },
+    {
+        function: 'generate_jwt',
+        protocol: {
+            pre_states: ['AUTHENTICATED'],
+            post_states: ['TOKEN_ISSUED'],
+            invalidate: ['AUTHENTICATED']
+        }
+    },
+    {
+        function: 'create_session',
+        protocol: {
+            pre_states: ['TOKEN_ISSUED'],
+            post_states: ['SESSION_ACTIVE'],
+            invalidate: ['TOKEN_ISSUED']
+        }
+    }
+];
+function runDemo() {
+    console.log('═══ Semantic State Graph (SSG) 原型演示 ═══\n');
+    console.log('场景1：合法序列 (verify_password → generate_jwt → create_session)');
+    const legalSequence = ['verify_password', 'generate_jwt', 'create_session'];
+    const validator1 = new ssg_validator_1.StateMachineValidator(authProtocol, 'UNAUTHENTICATED');
+    let allPassed = true;
+    for (const fn of legalSequence) {
+        const result = validator1.apply(fn);
+        if (!result.valid) {
+            console.log(`  ❌ ${fn} 被拦截：${result.error}`);
+            allPassed = false;
+            break;
+        }
+        else {
+            console.log(`  ✅ ${fn} 通过，当前状态：[${result.statesAfter}]`);
+        }
+    }
+    if (allPassed)
+        console.log('  ✔ 合法序列全部通过\n');
+    console.log('场景2：非法序列 (generate_jwt → verify_password)');
+    const illegalSequence = ['generate_jwt', 'verify_password'];
+    const validator2 = new ssg_validator_1.StateMachineValidator(authProtocol, 'UNAUTHENTICATED');
+    for (const fn of illegalSequence) {
+        const result = validator2.apply(fn);
+        if (!result.valid) {
+            console.log(`  🚫 ${fn} 被拦截：${result.error}`);
+            console.log('  🛡️ SSG 成功阻止了非法状态跃迁！');
+            break;
+        }
+        else {
+            console.log(`  ✅ ${fn} 通过，当前状态：[${result.statesAfter}]`);
+        }
+    }
+    console.log('\n═══ 演示完成 ═══');
+}
+runDemo();

package/dist/planner.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plan = plan;
+const llm_1 = require("./llm");
+const action_runtime_1 = require("./action-runtime");
+const validator_1 = require("./validator");
+const semantic_validator_1 = require("./semantic-validator");
+const feedback_1 = require("./feedback");
+const utils_1 = require("./utils");
+const failure_corpus_1 = require("./failure-corpus");
+const memory_layer_1 = require("./memory-layer");
+const fs = __importStar(require("fs"));
+function enrichActions(actions, ir) {
+    return actions.map(a => {
+        if (!a || !a.kind)
+            return a;
+        if (a.kind === "call" && a.function && a.args) {
+            const def = ir.find(f => f.name === a.function);
+            if (def) {
+                a.args = a.args.map((arg, i) => {
+                    if (!arg)
+                        return { name: `p${i}`, type: 'any', value: null };
+                    const paramDef = def.params[i];
+                    if (typeof arg === 'object' && arg.value !== undefined) {
+                        return { name: paramDef?.name || `p${i}`, type: paramDef?.type || 'any', value: arg.value };
+                    }
+                    return { name: paramDef?.name || `p${i}`, type: paramDef?.type || 'any', value: arg };
+                });
+            }
+        }
+        if (a.kind === "if") {
+            a.thenActions = enrichActions(a.thenActions || [], ir);
+            a.elseActions = enrichActions(a.elseActions || [], ir);
+        }
+        return a;
+    });
+}
+function determineSVL(errors) {
+    if (errors.some(e => e.includes("不存在")))
+        return "SVL-1";
+    if (errors.some(e => e.includes("类型不匹配") || e.includes("参数数量")))
+        return "SVL-2";
+    if (errors.some(e => e.includes("变量") && (e.includes("未定义") || e.includes("引用自身"))))
+        return "SVL-3";
+    if (errors.some(e => e.includes("协议") || e.includes("状态")))
+        return "SVL-4";
+    return "SVL-1";
+}
+function determineConstraintType(svl) {
+    switch (svl) {
+        case "SVL-1": return "symbol_existence";
+        case "SVL-2": return "type_mismatch";
+        case "SVL-3": return "dataflow";
+        case "SVL-4": return "protocol";
+    }
+}
+async function plan(userIntent) {
+    (0, llm_1.resetCallCount)();
+    const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+    // ========== 语义模板快速通道 ==========
+    const cachedTemplate = (0, memory_layer_1.findSemanticTemplate)(userIntent);
+    if (cachedTemplate && cachedTemplate.successRate >= 0.8 && cachedTemplate.useCount >= 2) {
+        console.log("⚡ 命中语义模板，直接复用已验证序列");
+        (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: cachedTemplate.actionSequence, success: true });
+        return cachedTemplate.actionSequence;
+    }
+    // ====================================
+    const keywords = (0, utils_1.extractKeywords)(userIntent);
+    const scored = ir.map((f) => {
+        let score = 0;
+        for (const kw of keywords) {
+            score += (0, utils_1.jaccardSimilarity)(f.name.toLowerCase(), kw);
+            if (f.name.toLowerCase().includes(kw))
+                score += 0.5;
+        }
+        return { ...f, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const topFuncs = scored.slice(0, 15);
+    const funcList = topFuncs.map((f) => {
+        const rate = (0, feedback_1.getFunctionSuccessRate)(f.name);
+        const star = rate > 0.8 ? "⭐" : rate > 0.5 ? "👍" : "⚠️";
+        const params = f.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+        return `${star} ${f.name}(${params}) [${f.params.length}个参数] -> ${f.returnType} (成功率: ${(rate * 100).toFixed(0)}%)`;
+    }).join("\n");
+    const matchFunc = userIntent.match(/(?:实现|implement|编写|创建)\s*(\w+)\s*(?:函数|function)?/i);
+    const forbiddenFuncs = [];
+    if (matchFunc) {
+        const targetName = matchFunc[1];
+        if (ir.find((f) => f.name.toLowerCase() === targetName.toLowerCase())) {
+            forbiddenFuncs.push(targetName);
+        }
+    }
+    const exampleCode = `assign("query_key", "user:123")
+callAssign("cache_get", "cached_data", "query_key")
+ifElse("cached_data", () => {
+  output("cached_data")
+}, () => {
+  callAssign("query_data", "fresh_data", "query_key")
+  call("cache_set", "query_key", "fresh_data")
+  output("fresh_data")
+})`;
+    const basePrompt = `你能使用的函数：
+${funcList}
+
+绝对禁止调用列表外函数。
+
+示例（缓存查询，注意 assign 先于条件）：
+${exampleCode}
+
+全局函数及用法规则：
+- 声明变量：assign("变量名", "值") 或 callAssign("函数", "变量名", ...)
+- 条件分支：ifElse("变量名", () => { ... }, () => { ... })
+- 简单分支：ifBlock("变量名", () => { ... })
+- 调用：call("函数", "arg1", ...)
+- 返回：output("值或变量名")
+
+铁律：
+1. 必须先 assign 或 callAssign 再使用变量。
+2. 参数数量必须与函数声明一致。
+3. 条件括号内只能是已声明的变量名。
+
+需求：
+${userIntent}
+
+只输出代码。`;
+    let finalActions = [];
+    let currentPrompt = basePrompt;
+    for (let r = 0; r < 3; r++) {
+        let text;
+        try {
+            text = await (0, llm_1.generate)(currentPrompt);
+        }
+        catch (e) {
+            continue;
+        }
+        if (!text)
+            continue;
+        text = text.replace(/```javascript\s*/gi, '').replace(/```\s*/g, '').trim();
+        console.log("📝 LLM 生成的代码:\n", text);
+        const rawActions = (0, action_runtime_1.executeActionCode)(text);
+        if (!rawActions || rawActions.length === 0) {
+            console.log("⚠️ 代码执行失败，重试...");
+            currentPrompt = basePrompt + "\n上一次代码无效，请严格模仿示例。";
+            continue;
+        }
+        const enriched = enrichActions(rawActions, ir);
+        const filtered = enriched.filter(a => !forbiddenFuncs.includes(a.function || ''));
+        const seqResult = (0, validator_1.validateActionSequence)(filtered);
+        if (!seqResult.valid) {
+            const errorsFlat = seqResult.errors.flat();
+            console.log("⚠️ 序列校验失败:", errorsFlat.join(", "));
+            const svl = determineSVL(errorsFlat);
+            (0, failure_corpus_1.recordFailure)({
+                intent: userIntent,
+                projectFunctions: ir.map((f) => f.name),
+                violatedSVL: svl,
+                constraintType: determineConstraintType(svl),
+                actionSequence: filtered,
+                errorDetail: errorsFlat.join("; "),
+            });
+            (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: filtered, success: false, svlViolated: svl });
+            currentPrompt = basePrompt + `\n错误：${errorsFlat.join("；")}。请修正。`;
+            continue;
+        }
+        const semResult = (0, semantic_validator_1.checkSemantic)(userIntent, filtered);
+        if (!semResult.valid) {
+            console.log("⚠️ 语义校验失败:", semResult.errors.join(", "));
+            (0, failure_corpus_1.recordFailure)({
+                intent: userIntent,
+                projectFunctions: ir.map((f) => f.name),
+                violatedSVL: "SVL-4",
+                constraintType: "protocol",
+                actionSequence: filtered,
+                errorDetail: semResult.errors.join("; "),
+            });
+            (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: filtered, success: false, svlViolated: "SVL-4" });
+            currentPrompt = basePrompt + `\n错误：${semResult.errors.join("；")}。请修正。`;
+            continue;
+        }
+        finalActions = filtered;
+        break;
+    }
+    if (finalActions.length > 0) {
+        (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: finalActions, success: true });
+    }
+    else {
+        (0, memory_layer_1.recordEpisode)({ intent: userIntent, actions: [], success: false });
+    }
+    return finalActions;
+}

package/dist/python-emitter.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPython = emitPython;
+const fs = __importStar(require("fs"));
+function toPythonModule(filePath) {
+    let module = filePath.replace(/\.py$/, "").replace(/\//g, ".");
+    module = module.replace(/\.$/, "").replace(/\.__init__$/, "");
+    return module;
+}
+function pythonValue(val) {
+    if (typeof val === 'string')
+        return JSON.stringify(val);
+    if (typeof val === 'number' || typeof val === 'boolean')
+        return String(val);
+    if (val === null || val === undefined)
+        return 'None';
+    if (typeof val === 'object') {
+        const entries = Object.entries(val).map(([k, v]) => `${JSON.stringify(k)}: ${pythonValue(v)}`);
+        return `{${entries.join(', ')}}`;
+    }
+    return 'None';
+}
+function emitPython(actions) {
+    const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+    const funcToFile = new Map();
+    const funcToParams = new Map();
+    for (const f of ir) {
+        funcToFile.set(f.name, f.file);
+        funcToParams.set(f.name, f.params || []);
+    }
+    const imports = new Map();
+    const collectImports = (action) => {
+        if (action.kind === "call" && action.function) {
+            const file = funcToFile.get(action.function);
+            if (file) {
+                const mod = toPythonModule(file);
+                if (!imports.has(mod))
+                    imports.set(mod, new Set());
+                imports.get(mod).add(action.function);
+            }
+        }
+        else if (action.kind === "if") {
+            (action.thenActions || []).forEach(collectImports);
+            (action.elseActions || []).forEach(collectImports);
+        }
+    };
+    for (const a of actions)
+        collectImports(a);
+    let code = "";
+    for (const [mod, funcs] of imports) {
+        code += `from ${mod} import ${Array.from(funcs).join(", ")}\n`;
+    }
+    code += "\n\ndef main():\n";
+    // 使用全局变量跟踪已声明的变量
+    const declaredVars = new Set();
+    const argToPython = (val) => {
+        if (typeof val === 'string') {
+            if (declaredVars.has(val))
+                return val;
+            return JSON.stringify(val);
+        }
+        return pythonValue(val);
+    };
+    // 转换为 Python 代码行，使用数字缩进级别以确保一致性
+    const convertLines = (action, indentLevel) => {
+        const indent = "    ".repeat(indentLevel);
+        if (!action || !action.kind)
+            return [];
+        if (action.kind === "call") {
+            const fname = action.function || "unknown";
+            const args = (action.args || []).map((a) => argToPython(a.value)).join(", ");
+            const resultVar = action.assignTo || `_res`;
+            declaredVars.add(resultVar);
+            return [`${indent}${resultVar} = ${fname}(${args})`];
+        }
+        if (action.kind === "if") {
+            const lines = [];
+            lines.push(`${indent}if ${action.condition}:`);
+            const thenActions = action.thenActions || [];
+            const elseActions = action.elseActions || [];
+            if (thenActions.length > 0) {
+                for (const a of thenActions) {
+                    lines.push(...convertLines(a, indentLevel + 1));
+                }
+            }
+            else {
+                // 防止空块
+                lines.push(`${indent}    pass`);
+            }
+            if (elseActions.length > 0) {
+                lines.push(`${indent}else:`);
+                for (const a of elseActions) {
+                    lines.push(...convertLines(a, indentLevel + 1));
+                }
+            }
+            return lines;
+        }
+        if (action.kind === "return") {
+            const val = action.value;
+            if (typeof val === 'string') {
+                if (declaredVars.has(val))
+                    return [`${indent}return ${val}`];
+                return [`${indent}return ${JSON.stringify(val)}`];
+            }
+            return [`${indent}return ${pythonValue(val)}`];
+        }
+        return [];
+    };
+    const lines = [];
+    for (const a of actions) {
+        lines.push(...convertLines(a, 1));
+    }
+    code += lines.join("\n") + "\n";
+    code += "\nif __name__ == '__main__':\n    main()\n";
+    return code;
+}

package/dist/rule-miner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const failure_corpus_1 = require("./failure-corpus");
+console.log("═══ 失败模式分析 ═══");
+const patterns = (0, failure_corpus_1.getTopFailurePatterns)(5);
+console.log("Top 5 失败模式:");
+patterns.forEach(p => console.log(`  ${p.pattern}: ${p.count} 次`));
+console.log("\n候选规则建议:");
+const rules = (0, failure_corpus_1.generateCandidateRules)();
+rules.forEach(r => console.log(`  - ${r}`));

package/dist/runtime.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAndCheck = runAndCheck;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function runAndCheck(code) {
+    // 把临时文件写入 test-login 目录，使用它的 tsconfig 编译
+    const tmpDir = path.resolve("test-login");
+    const tmpFile = path.join(tmpDir, "_temp_check.ts");
+    fs.writeFileSync(tmpFile, code);
+    try {
+        (0, child_process_1.execSync)(`npx ts-node --project ${tmpDir}/tsconfig.json ${tmpFile}`, {
+            timeout: 5000,
+            encoding: "utf-8",
+        });
+        fs.unlinkSync(tmpFile);
+        return { success: true };
+    }
+    catch (e) {
+        if (fs.existsSync(tmpFile))
+            fs.unlinkSync(tmpFile);
+        return { success: false, error: e.stderr?.toString() || e.toString() };
+    }
+}

package/dist/search-planner.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchPlan = searchPlan;
+const validator_1 = require("./validator");
+const llm_1 = require("./llm");
+const feedback_1 = require("./feedback");
+const utils_1 = require("./utils");
+const fs = __importStar(require("fs"));
+// ⚖️ 可调权重（修改这些值后重新运行压力测试即可）
+const WEIGHT_STATIC_SCORE = 0.3; // 静态文本相似度的权重
+const WEIGHT_LLM_SCORE = 0.7; // LLM 评分的权重
+const WEIGHT_HISTORY = 0.4; // 反馈系统成功率的权重
+const WEIGHT_GOAL_COMPLETION = 0.5; // 目标完成奖励
+const STATIC_HIGH_THRESHOLD = 0.6; // 静态评分超过此值时，跳过LLM调用
+function loadIR() {
+    return JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+}
+const staticScoreCache = new Map();
+function getStaticScore(funcName, goal) {
+    const key = `${funcName}|${goal}`;
+    if (staticScoreCache.has(key))
+        return staticScoreCache.get(key);
+    let s = 0;
+    const combined = funcName.toLowerCase();
+    const goalWords = goal.toLowerCase().split(/\s+/);
+    for (const w of goalWords) {
+        if (combined.includes(w))
+            s += 0.3;
+        s += (0, utils_1.jaccardSimilarity)(combined, w) * 0.1;
+    }
+    s = Math.min(1, s);
+    staticScoreCache.set(key, s);
+    return s;
+}
+async function decomposeGoals(intent, functions) {
+    const funcNames = functions.map(f => f.name).join(", ");
+    const prompt = `将以下需求分解为2-3个独立的子目标，每个子目标必须是一个简短的动词短语。绝对不能合并。\n需求：${intent}\n可用函数：${funcNames}\n只返回JSON字符串数组，如 ["验证密码","生成JWT","返回错误"]`;
+    const text = await (0, llm_1.generate)(prompt);
+    try {
+        let cleaned = text.replace(/```json\s*/gi, '[').replace(/```\s*/g, ']');
+        const match = cleaned.match(/\[([\s\S]*)\]/);
+        if (match) {
+            let parsed = JSON.parse(match[0]);
+            if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0] === 'object') {
+                parsed = parsed.map((o) => o.description || o.subgoal || String(o));
+            }
+            if (typeof parsed === 'string')
+                parsed = [parsed];
+            const result = [];
+            for (const item of parsed) {
+                if (typeof item === 'string' && item.includes(','))
+                    result.push(...item.split(',').map(s => s.trim()).filter(s => s));
+                else if (typeof item === 'string')
+                    result.push(item);
+            }
+            return result.slice(0, 3);
+        }
+    }
+    catch { }
+    return [intent];
+}
+async function functionMatchesGoal(funcName, goal, staticScore) {
+    if (staticScore > STATIC_HIGH_THRESHOLD)
+        return staticScore;
+    const prompt = `函数 ${funcName} 对 "${goal}" 的贡献度（0-10整数），只返回数字:`;
+    const resp = await (0, llm_1.generate)(prompt);
+    const s = parseFloat(resp.trim());
+    return isNaN(s) ? 0.3 : Math.min(1, s / 10);
+}
+async function searchPlan(intent, beamWidth = 2, maxDepth = 6) {
+    (0, llm_1.resetCallCount)();
+    staticScoreCache.clear();
+    const ir = loadIR();
+    const goals = await decomposeGoals(intent, ir);
+    console.log("🎯 目标栈:", goals);
+    let beam = [{
+            actions: [],
+            declaredVars: new Map(),
+            currentGoalIndex: 0,
+            score: 0,
+        }];
+    let bestCandidate = null;
+    for (let step = 0; step < maxDepth; step++) {
+        const newCandidates = [];
+        for (const cand of beam) {
+            if (cand.currentGoalIndex >= goals.length) {
+                newCandidates.push(cand);
+                continue;
+            }
+            const currentGoal = goals[cand.currentGoalIndex];
+            const scoredFuncs = ir.map((f) => ({
+                ...f,
+                staticScore: getStaticScore(f.name, currentGoal)
+            })).filter((f) => f.staticScore > 0.05)
+                .sort((a, b) => b.staticScore - a.staticScore)
+                .slice(0, 5);
+            for (const func of scoredFuncs) {
+                const alreadyUsed = cand.actions.some(a => a.kind === "call" && a.function === func.name && a._goalIndex === cand.currentGoalIndex);
+                if (alreadyUsed)
+                    continue;
+                const relevance = await functionMatchesGoal(func.name, currentGoal, func.staticScore);
+                if (relevance < 0.2)
+                    continue;
+                const args = func.params.map((p) => ({
+                    name: p.name,
+                    type: p.type,
+                    value: findCompatibleVar(cand.declaredVars, p.type) || `input_${step}_${p.name}`,
+                }));
+                const action = { kind: "call", function: func.name, args, assignTo: `var_${step}_${func.name}` };
+                action._goalIndex = cand.currentGoalIndex;
+                const validation = (0, validator_1.validateAction)(action);
+                if (!validation.valid)
+                    continue;
+                const newVars = new Map(cand.declaredVars);
+                if (action.assignTo)
+                    newVars.set(action.assignTo, func.returnType);
+                const goalCompleted = relevance > 0.5; // 降低目标完成门槛
+                const nextGoalIndex = goalCompleted ? cand.currentGoalIndex + 1 : cand.currentGoalIndex;
+                const successRate = (0, feedback_1.getFunctionSuccessRate)(func.name);
+                const finalRelevance = (func.staticScore * WEIGHT_STATIC_SCORE + relevance * WEIGHT_LLM_SCORE) / (WEIGHT_STATIC_SCORE + WEIGHT_LLM_SCORE);
+                const newScore = cand.score + successRate * WEIGHT_HISTORY + finalRelevance * (1 - WEIGHT_HISTORY) + (goalCompleted ? WEIGHT_GOAL_COMPLETION : 0);
+                newCandidates.push({ actions: [...cand.actions, action], declaredVars: newVars, currentGoalIndex: nextGoalIndex, score: newScore });
+                if (newCandidates.length > beamWidth * 10)
+                    break;
+            }
+        }
+        newCandidates.sort((a, b) => b.score - a.score);
+        beam = newCandidates.slice(0, beamWidth);
+        const complete = beam.find(c => c.currentGoalIndex >= goals.length);
+        if (complete && (!bestCandidate || complete.score > bestCandidate.score))
+            bestCandidate = complete;
+        if (beam.length === 0)
+            break;
+    }
+    const winner = bestCandidate || beam[0];
+    return winner ? winner.actions : [];
+}
+function findCompatibleVar(declaredVars, neededType) {
+    for (const [name, type] of declaredVars) {
+        if (type === neededType || neededType === "any" || type === "any")
+            return name;
+    }
+    return null;
+}