progmune-runtime 2.0.0

package/dist/action-runtime.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActionCode = executeActionCode;
+class ActionBuilder {
+    constructor() {
+        this.actions = [];
+        this.vars = {};
+    }
+    call(func, args, assignTo) {
+        const normalizedArgs = args.map(a => {
+            if (typeof a === 'object' && a !== null && !('name' in a && 'type' in a && 'value' in a)) {
+                return { name: '', type: 'any', value: a };
+            }
+            return a;
+        });
+        const action = { kind: "call", function: func, args: normalizedArgs };
+        if (assignTo) {
+            action.assignTo = assignTo;
+            this.vars[assignTo] = assignTo;
+        }
+        this.actions.push(action);
+    }
+    ifBlock(condition, thenFn) {
+        const sub = new ActionBuilder();
+        sub.vars = { ...this.vars };
+        thenFn();
+        this.actions.push({ kind: "if", condition, thenActions: sub.actions });
+        Object.assign(this.vars, sub.vars);
+    }
+    ifElse(condition, thenFn, elseFn) {
+        const thenBuilder = new ActionBuilder();
+        const elseBuilder = new ActionBuilder();
+        thenBuilder.vars = { ...this.vars };
+        elseBuilder.vars = { ...this.vars };
+        thenFn();
+        elseFn();
+        this.actions.push({
+            kind: "if",
+            condition,
+            thenActions: thenBuilder.actions,
+            elseActions: elseBuilder.actions
+        });
+        Object.assign(this.vars, thenBuilder.vars, elseBuilder.vars);
+    }
+    assign(target, value) {
+        this.actions.push({ kind: "assign", target, value });
+        this.vars[target] = target;
+    }
+    output(value) {
+        this.actions.push({ kind: "return", value });
+    }
+}
+let currentVars = {};
+function executeActionCode(code) {
+    const root = new ActionBuilder();
+    currentVars = {};
+    const apiFuncs = {
+        call: (...args) => root.call(args[0], args.slice(1)),
+        callAssign: (...args) => {
+            const f = args[0];
+            const assignTo = args[1];
+            root.call(f, args.slice(2), assignTo);
+        },
+        ifBlock: (cond, fn) => root.ifBlock(cond, () => fn()),
+        ifElse: (cond, thenFn, elseFn) => root.ifElse(cond, () => thenFn(), () => elseFn()),
+        assign: (t, v) => {
+            root.assign(t, v);
+            currentVars[t] = v;
+        },
+        output: (v) => root.output(v),
+    };
+    const apiNames = ['call', 'callAssign', 'ifBlock', 'ifElse', 'assign', 'output'];
+    const apiValues = apiNames.map(n => apiFuncs[n]);
+    try {
+        const proxyVars = new Proxy(currentVars, {
+            get(target, prop) {
+                if (typeof prop === 'string' && prop in target)
+                    return target[prop];
+                return undefined;
+            },
+            set(target, prop, value) {
+                if (typeof prop === 'string')
+                    target[prop] = value;
+                return true;
+            }
+        });
+        const wrappedCode = `with(vars) { ${code} }`;
+        const fn = new Function('vars', ...apiNames, wrappedCode);
+        fn(proxyVars, ...apiValues);
+        return root.actions;
+    }
+    catch (e) {
+        console.error("执行 Action 代码失败:", e);
+        return null;
+    }
+}

package/dist/actions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/consolidate.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_layer_1 = require("./memory-layer");
+console.log("═══ 记忆巩固 ═══");
+const recent = (0, memory_layer_1.getRecentEpisodes)(10);
+console.log(`情景记忆: ${recent.length} 条`);
+console.log(`成功: ${recent.filter(e => e.success).length} 条, 失败: ${recent.filter(e => !e.success).length} 条`);
+(0, memory_layer_1.consolidateSemantic)(3);
+console.log("巩固完成。");

package/dist/emitter.js

@@ -0,0 +1,166 @@
+"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.emitCode = emitCode;
+const fs = __importStar(require("fs"));
+const BASIC_TYPES = new Set([
+    "string", "number", "boolean", "any", "void", "undefined", "null",
+    "str", "int", "float", "bool", "list", "dict", "tuple", "bytes",
+]);
+function getImportPath(file) {
+    return "./" + file.replace(/\.ts$|\.tsx$/, "");
+}
+function emitCode(actions) {
+    const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+    const fnIndex = new Map();
+    const fnMeta = new Map();
+    for (const f of ir) {
+        fnIndex.set(f.name, f.file);
+        fnMeta.set(f.name, f);
+    }
+    const imports = new Map();
+    const typeImports = new Map();
+    const collect = (action) => {
+        if (action.kind === "call" && action.function) {
+            const file = fnIndex.get(action.function);
+            const meta = fnMeta.get(action.function);
+            if (file) {
+                if (!imports.has(file))
+                    imports.set(file, new Set());
+                imports.get(file).add(action.function);
+                if (meta?.params) {
+                    for (const p of meta.params) {
+                        if (!BASIC_TYPES.has(p.type)) {
+                            if (!typeImports.has(file))
+                                typeImports.set(file, new Set());
+                            typeImports.get(file).add(p.type);
+                        }
+                    }
+                }
+            }
+        }
+        else if (action.kind === "if") {
+            (action.thenActions || []).forEach(collect);
+            (action.elseActions || []).forEach(collect);
+        }
+        else if (action.kind === "for") {
+            (action.bodyActions || []).forEach(collect);
+        }
+    };
+    for (const a of actions)
+        collect(a);
+    let code = "";
+    for (const [file, funcSet] of imports)
+        code += `import { ${[...funcSet].join(", ")} } from "${getImportPath(file)}";\n`;
+    for (const [file, typeSet] of typeImports)
+        code += `import type { ${[...typeSet].join(", ")} } from "${getImportPath(file)}";\n`;
+    code += "\nexport function main() {\n";
+    const declared = new Set();
+    let counter = 0;
+    const convert = (action, indent = "  ") => {
+        if (!action || !action.kind)
+            return "";
+        if (action.kind === "call") {
+            const meta = fnMeta.get(action.function || "");
+            const args = (action.args || []).map((a, i) => {
+                if (typeof a === "string") {
+                    if (declared.has(a))
+                        return a;
+                    return JSON.stringify(a);
+                }
+                const val = a?.value;
+                if (typeof val === "string" && declared.has(val))
+                    return val;
+                const paramType = meta?.params?.[i]?.type || "any";
+                if (BASIC_TYPES.has(paramType)) {
+                    if (paramType === "string" || paramType === "str")
+                        return `"defaultStr"`;
+                    if (paramType === "number" || paramType === "int" || paramType === "float")
+                        return "0";
+                    if (paramType === "boolean" || paramType === "bool")
+                        return "false";
+                    return `"default"`;
+                }
+                if (paramType === "UserPayload")
+                    return `{ id: 1, role: "user" } as UserPayload`;
+                if (paramType === "PasswordHash")
+                    return `"defaultHash"`;
+                if (paramType === "Token")
+                    return `"defaultToken"`;
+                return `{} as ${paramType}`;
+            }).join(", ");
+            const varName = action.assignTo || `result_${counter++}`;
+            declared.add(varName);
+            return `${indent}const ${varName} = ${action.function}(${args});`;
+        }
+        else if (action.kind === "if") {
+            let lines = `${indent}if (${action.condition}) {\n`;
+            for (const a of (action.thenActions || []))
+                lines += convert(a, indent + "  ") + "\n";
+            lines += `${indent}}`;
+            if (action.elseActions && action.elseActions.length > 0) {
+                lines += ` else {\n`;
+                for (const a of action.elseActions)
+                    lines += convert(a, indent + "  ") + "\n";
+                lines += `${indent}}`;
+            }
+            return lines;
+        }
+        else if (action.kind === "for") {
+            let lines = `${indent}for (const ${action.variable} of ${action.iterable}) {\n`;
+            for (const a of (action.bodyActions || []))
+                lines += convert(a, indent + "  ") + "\n";
+            lines += `${indent}}`;
+            return lines;
+        }
+        else if (action.kind === "assign") {
+            const val = typeof action.value === "string" ? JSON.stringify(action.value) : convert(action.value);
+            if (action.target)
+                declared.add(action.target);
+            return `${indent}const ${action.target} = ${val};`;
+        }
+        else if (action.kind === "return") {
+            const val = typeof action.value === "string" ?
+                (declared.has(action.value) ? action.value : JSON.stringify(action.value)) :
+                convert(action.value);
+            return `${indent}return ${val};`;
+        }
+        return "";
+    };
+    for (const a of actions)
+        code += convert(a) + "\n";
+    code += "}\nmain();\n";
+    return code;
+}

package/dist/extract-ir-python.js

@@ -0,0 +1,55 @@
+"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.extractIRPython = extractIRPython;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function extractIRPython(projectRoot) {
+    const scriptPath = path.resolve(__dirname, "../tools/extract_ir.py");
+    const cmd = `python3 "${scriptPath}" "${projectRoot}"`;
+    try {
+        (0, child_process_1.execSync)(cmd, { encoding: "utf-8", stdio: "pipe" });
+    }
+    catch (e) {
+        console.error("Python IR 提取失败:", e.stderr?.toString() || e.toString());
+        return [];
+    }
+    const irPath = path.resolve("ir.json");
+    if (fs.existsSync(irPath)) {
+        return JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    }
+    return [];
+}

package/dist/extract-ir.js

@@ -0,0 +1,143 @@
+"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.extractIR = extractIR;
+const ts_morph_1 = require("ts-morph");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// 获取类型节点的结构化描述
+function getTypeDetail(typeNode) {
+    if (!typeNode)
+        return "";
+    const text = typeNode.getText();
+    // 简单处理联合类型
+    if (ts_morph_1.Node.isUnionTypeNode(typeNode)) {
+        return typeNode.getTypeNodes().map((t) => getTypeDetail(t)).join(" | ");
+    }
+    // 处理泛型
+    if (ts_morph_1.Node.isTypeReference(typeNode)) {
+        const typeName = typeNode.getTypeName().getText();
+        const typeArgs = typeNode.getTypeArguments();
+        if (typeArgs.length > 0) {
+            const args = typeArgs.map((ta) => getTypeDetail(ta)).join(", ");
+            return `${typeName}<${args}>`;
+        }
+        return typeName;
+    }
+    // 处理数组/元组
+    if (ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        return getTypeDetail(typeNode.getElementTypeNode()) + "[]";
+    }
+    // 其他类型直接返回文本
+    return text;
+}
+function getParamType(param) {
+    const typeNode = param.getTypeNode?.();
+    return typeNode ? typeNode.getText() : "any";
+}
+function getParamTypeDetail(param) {
+    const typeNode = param.getTypeNode?.();
+    return typeNode ? getTypeDetail(typeNode) : "";
+}
+function getReturnType(func) {
+    const typeNode = func.getReturnTypeNode?.();
+    return typeNode ? typeNode.getText() : "any";
+}
+function getReturnTypeDetail(func) {
+    const typeNode = func.getReturnTypeNode?.();
+    return typeNode ? getTypeDetail(typeNode) : "";
+}
+function extractDirectCalls(func) {
+    const body = func.getBody();
+    if (!body)
+        return [];
+    const calls = [];
+    body.forEachDescendant((node, traversal) => {
+        if (ts_morph_1.Node.isCallExpression(node)) {
+            const expr = node.getExpression();
+            if (ts_morph_1.Node.isIdentifier(expr))
+                calls.push(expr.getText());
+            else if (ts_morph_1.Node.isPropertyAccessExpression(expr))
+                calls.push(expr.getName());
+        }
+        if (ts_morph_1.Node.isFunctionDeclaration(node) || ts_morph_1.Node.isArrowFunction(node))
+            traversal.skip();
+    });
+    return [...new Set(calls)];
+}
+function extractIR(projectRoot) {
+    const absRoot = path.resolve(projectRoot);
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath: path.join(absRoot, "tsconfig.json"),
+        skipAddingFilesFromTsConfig: false,
+    });
+    if (!fs.existsSync(path.join(absRoot, "tsconfig.json"))) {
+        project.addSourceFilesAtPaths(path.join(absRoot, "**/*.ts"));
+    }
+    const funcs = [];
+    for (const sf of project.getSourceFiles()) {
+        const relPath = path.relative(absRoot, sf.getFilePath());
+        for (const f of sf.getFunctions()) {
+            const name = f.getName();
+            if (!name)
+                continue;
+            funcs.push({
+                name,
+                params: f.getParameters().map(p => ({
+                    name: p.getName(),
+                    type: getParamType(p),
+                    typeDetail: getParamTypeDetail(p),
+                })),
+                returnType: getReturnType(f),
+                returnTypeDetail: getReturnTypeDetail(f),
+                file: relPath,
+                calls: extractDirectCalls(f),
+            });
+        }
+        // 箭头函数类似处理，略
+    }
+    return funcs;
+}
+// 若直接运行
+if (require.main === module) {
+    const root = process.argv[2];
+    if (!root) {
+        console.error("用法: ts-node extract-ir.ts <项目根>");
+        process.exit(1);
+    }
+    const fns = extractIR(root);
+    fs.writeFileSync("ir.json", JSON.stringify(fns, null, 2));
+    console.log(`✅ IR 提取完成: ${fns.length} 个函数 -> ir.json`);
+}

package/dist/failure-corpus.js

@@ -0,0 +1,113 @@
+"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.recordFailure = recordFailure;
+exports.getAllFailures = getAllFailures;
+exports.getFailuresBySVL = getFailuresBySVL;
+exports.getTopFailurePatterns = getTopFailurePatterns;
+exports.generateCandidateRules = generateCandidateRules;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CORPUS_DIR = path.resolve(__dirname, "../failure_corpus");
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+function recordFailure(record) {
+    ensureDir(CORPUS_DIR);
+    const date = new Date().toISOString().slice(0, 10);
+    const dateDir = path.join(CORPUS_DIR, date);
+    ensureDir(dateDir);
+    const id = `fail_${Date.now()}`;
+    const fullRecord = {
+        ...record,
+        id,
+        timestamp: new Date().toISOString(),
+    };
+    const filename = `${id}.json`;
+    const filepath = path.join(dateDir, filename);
+    fs.writeFileSync(filepath, JSON.stringify(fullRecord, null, 2));
+    console.log(`[FailureCorpus] 记录失败案例: ${id} [${record.violatedSVL}]`);
+}
+function getAllFailures() {
+    const records = [];
+    if (!fs.existsSync(CORPUS_DIR))
+        return records;
+    const dirs = fs.readdirSync(CORPUS_DIR);
+    for (const dir of dirs) {
+        const dirPath = path.join(CORPUS_DIR, dir);
+        if (!fs.statSync(dirPath).isDirectory())
+            continue;
+        const files = fs.readdirSync(dirPath);
+        for (const file of files) {
+            if (file.endsWith(".json")) {
+                const content = fs.readFileSync(path.join(dirPath, file), "utf-8");
+                records.push(JSON.parse(content));
+            }
+        }
+    }
+    return records;
+}
+function getFailuresBySVL(level) {
+    return getAllFailures().filter(r => r.violatedSVL === level);
+}
+function getTopFailurePatterns(limit = 5) {
+    const counts = new Map();
+    const all = getAllFailures();
+    for (const r of all) {
+        const key = `${r.violatedSVL}:${r.constraintType}`;
+        counts.set(key, (counts.get(key) || 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([pattern, count]) => ({ pattern, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, limit);
+}
+function generateCandidateRules() {
+    const patterns = getTopFailurePatterns(3);
+    const rules = [];
+    for (const p of patterns) {
+        if (p.pattern === "SVL-4:protocol") {
+            rules.push("建议：为相关函数添加 SSG 协议约束，检查前置状态。");
+        }
+        else if (p.pattern === "SVL-1:symbol_existence") {
+            rules.push("建议：检查项目 IR 是否缺少必要的函数定义。");
+        }
+        else if (p.pattern === "SVL-3:dataflow") {
+            rules.push("建议：强化变量声明检查，确保变量使用前已初始化。");
+        }
+    }
+    return rules;
+}

package/dist/feedback.js

@@ -0,0 +1,73 @@
+"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.loadFeedback = loadFeedback;
+exports.saveFeedback = saveFeedback;
+exports.getFunctionSuccessRate = getFunctionSuccessRate;
+exports.recordRun = recordRun;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FEEDBACK_PATH = path.resolve(__dirname, "../feedback.json");
+function loadFeedback() {
+    if (!fs.existsSync(FEEDBACK_PATH))
+        return [];
+    return JSON.parse(fs.readFileSync(FEEDBACK_PATH, "utf-8"));
+}
+function saveFeedback(record) {
+    const data = loadFeedback();
+    data.push(record);
+    fs.writeFileSync(FEEDBACK_PATH, JSON.stringify(data, null, 2));
+}
+function getFunctionSuccessRate(funcName) {
+    const records = loadFeedback();
+    const funcRecords = records.filter(r => r.functionName === funcName);
+    if (funcRecords.length === 0)
+        return 0.5; // 中性值
+    const successCount = funcRecords.filter(r => r.success).length;
+    return successCount / funcRecords.length;
+}
+function recordRun(intent, actions, success, error) {
+    for (const action of actions) {
+        if (action.kind === "call") {
+            saveFeedback({
+                intent,
+                functionName: action.function,
+                success,
+                errorType: error ? error.split("\n")[0] : undefined,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+}