progmune-runtime 2.0.0

package/dist/semantic-validator.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSemantic = checkSemantic;
+let irCache = null;
+function loadContracts() {
+    if (irCache)
+        return irCache;
+    const raw = JSON.parse(require("fs").readFileSync("ir.json", "utf-8"));
+    irCache = raw;
+    return raw;
+}
+function matchIntent(intent, keywords) {
+    return keywords.some(kw => intent.includes(kw));
+}
+function checkSemantic(intent, actions) {
+    const ir = loadContracts();
+    const errors = [];
+    const callActions = actions.filter((a) => a.kind === "call");
+    for (const action of callActions) {
+        const funcDef = ir.find(f => f.name === action.function);
+        if (!funcDef || !funcDef.contracts)
+            continue;
+        for (const contract of funcDef.contracts) {
+            if (contract.when_intent && !matchIntent(intent, contract.when_intent))
+                continue;
+            switch (contract.type) {
+                case "require_param": {
+                    const arg = action.args?.find((a) => a.name === contract.param);
+                    if (arg && typeof arg.value === "string") {
+                        if (contract.not_empty && (arg.value.includes("{}") || arg.value.trim() === "")) {
+                            errors.push(`${action.function}: ${contract.description}`);
+                        }
+                    }
+                    break;
+                }
+                case "must_be_checked": {
+                    if (action.assignTo) {
+                        const usedInIf = actions.some(a => a.kind === "if" && a.condition === action.assignTo);
+                        if (!usedInIf) {
+                            errors.push(`${action.function}: ${contract.description} (变量 ${action.assignTo} 未用于if条件)`);
+                        }
+                    }
+                    else {
+                        errors.push(`${action.function}: ${contract.description} (未使用assignTo保存返回值)`);
+                    }
+                    break;
+                }
+                case "sequence_after": {
+                    const mustBefore = contract.function;
+                    const idxCurrent = callActions.indexOf(action);
+                    const idxBefore = callActions.findIndex(a => a.function === mustBefore);
+                    if (idxBefore === -1 || idxBefore > idxCurrent) {
+                        errors.push(`${action.function}: ${contract.description}`);
+                    }
+                    break;
+                }
+                case "param_from": {
+                    const arg = action.args?.find((a) => a.name === contract.param);
+                    if (arg && typeof arg.value === "string") {
+                        const sourceAction = callActions.find(a => a.function === contract.function && a.assignTo === arg.value);
+                        if (!sourceAction) {
+                            errors.push(`${action.function}: ${contract.description} (参数 ${arg.value} 未引用 ${contract.function} 的输出)`);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/semantic_guard_test.js

@@ -0,0 +1,106 @@
+"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 });
+const planner_1 = require("./planner");
+const validator_1 = require("./validator");
+const python_emitter_1 = require("./python-emitter");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// 直接使用当前目录下的 ir.json，不再重新提取
+const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+console.log(`IR: ${ir.length} 函数 (含合约)`);
+const intents = {
+    case1: "实现 login 函数，验证密码后生成JWT并返回",
+    case2: "实现用户注册，先加密密码，然后发送欢迎邮件",
+    case3: "实现带缓存的查询：先查缓存，若无则查询并更新缓存",
+    case4: "实现批量发送邮件：遍历用户列表，对每个活跃用户发送通知",
+    case5: "实现角色检查：验证用户是否为管理员，是则执行操作",
+    case6: "实现会话创建：验证凭据后，生成JWT，创建会话并缓存",
+    case7: "实现数据导出：获取所有用户数据，转换格式并保存到文件",
+    case8: "实现账户锁定：检查登录失败次数，超过阈值则锁定账户",
+    case9: "实现令牌刷新：验证旧令牌有效性，生成新令牌并更新会话",
+    case10: "实现用户注销：销毁会话，清理缓存，记录审计日志"
+};
+async function runSemanticTest() {
+    const results = [];
+    for (const [caseName, intent] of Object.entries(intents)) {
+        console.log(`\n🧪 ${caseName}: ${intent.substring(0, 50)}...`);
+        const actions = await (0, planner_1.plan)(intent);
+        if (!actions || actions.length === 0) {
+            results.push({ case: caseName, intent, generatedCode: "", actionSequence: [], syntaxPass: false, semanticError: true, runtimePass: false });
+            console.log("  ❌ 规划失败（无输出）");
+            continue;
+        }
+        const seqResult = (0, validator_1.validateActionSequence)(actions);
+        const syntaxPass = seqResult.valid;
+        if (!syntaxPass) {
+            console.log("  ❌ 语法/变量校验失败:", seqResult.errors.join(", "));
+            results.push({ case: caseName, intent, generatedCode: "", actionSequence: actions, syntaxPass: false, semanticError: true, runtimePass: false });
+            continue;
+        }
+        const code = (0, python_emitter_1.emitPython)(actions);
+        console.log("  📝 代码:\n" + code.split("\n").slice(0, 8).map(l => "    " + l).join("\n"));
+        const tmpFile = path.join(path.resolve("./test-semantic-guard"), "__test.py");
+        fs.writeFileSync(tmpFile, code);
+        let runtimePass = false;
+        try {
+            (0, child_process_1.execSync)(`python3 ${tmpFile}`, { timeout: 5000, encoding: "utf-8", cwd: path.resolve("./test-semantic-guard") });
+            runtimePass = true;
+        }
+        catch (e) { }
+        if (fs.existsSync(tmpFile))
+            fs.unlinkSync(tmpFile);
+        // 语义错误标记：如果序列中重要的业务函数缺失，视为语义错误（已在规划时由 checkSemantic 拦截）
+        const hasSemanticError = !runtimePass || actions.length <= 1; // 简单判断：只有1个调用的视为不完整
+        results.push({ case: caseName, intent, generatedCode: code, actionSequence: actions, syntaxPass, semanticError: hasSemanticError, runtimePass });
+        console.log(hasSemanticError ? "  ⚠️ 潜在语义错误" : "  ✅ 完整通过");
+    }
+    console.log("\n═══════════════════════════════════");
+    console.log("📊 语义阻断测试报告");
+    console.log("═══════════════════════════════════");
+    const total = results.length;
+    const syntaxBlocked = results.filter(r => !r.syntaxPass).length;
+    const semanticDetected = results.filter(r => r.semanticError).length;
+    const fullyClean = results.filter(r => r.syntaxPass && !r.semanticError).length;
+    console.log(`总测试案例: ${total}`);
+    console.log(`语法/变量层拦截: ${syntaxBlocked}`);
+    console.log(`语义错误检测: ${semanticDetected}`);
+    console.log(`完全安全通过: ${fullyClean}`);
+    console.log(`阻断率: ${((syntaxBlocked + semanticDetected) / total * 100).toFixed(0)}%`);
+    fs.writeFileSync("semantic_block_results.json", JSON.stringify(results, null, 2));
+    console.log("详细结果已保存到 semantic_block_results.json");
+}
+runSemanticTest().catch(console.error);

package/dist/ssg-validator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineValidator = void 0;
+class StateMachineValidator {
+    constructor(rules, initialState = 'INIT') {
+        this.currentStates = new Set([initialState]);
+        this.rules = new Map();
+        rules.forEach(r => this.rules.set(r.function, r.protocol));
+    }
+    apply(functionName) {
+        const rule = this.rules.get(functionName);
+        if (!rule) {
+            return { valid: true, statesAfter: [...this.currentStates] };
+        }
+        const hasValidPreState = rule.pre_states.some(s => this.currentStates.has(s));
+        if (!hasValidPreState) {
+            return {
+                valid: false,
+                error: `非法调用：${functionName} 要求前置状态 [${rule.pre_states}]，当前状态为 [${[...this.currentStates]}]`
+            };
+        }
+        if (rule.invalidate) {
+            rule.invalidate.forEach(s => this.currentStates.delete(s));
+        }
+        rule.post_states.forEach(s => this.currentStates.add(s));
+        return { valid: true, statesAfter: [...this.currentStates] };
+    }
+    getCurrentStates() {
+        return [...this.currentStates];
+    }
+}
+exports.StateMachineValidator = StateMachineValidator;

package/dist/test_failure_corpus.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const failure_corpus_1 = require("./failure-corpus");
+// 模拟记录一条失败案例
+(0, failure_corpus_1.recordFailure)({
+    intent: "实现一个登录函数",
+    projectFunctions: ["verify_password", "generate_jwt"],
+    violatedSVL: "SVL-4",
+    constraintType: "protocol",
+    actionSequence: [{ kind: "call", function: "generate_jwt" }],
+    errorDetail: "非法调用：generate_jwt 要求前置状态 [AUTHENTICATED]，当前状态为 [UNAUTHENTICATED]",
+    ssgState: "UNAUTHENTICATED",
+});
+// 打印当前统计
+console.log("当前失败案例总数:", (0, failure_corpus_1.getAllFailures)().length);
+console.log("高频模式:", (0, failure_corpus_1.getTopFailurePatterns)());

package/dist/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jaccardSimilarity = jaccardSimilarity;
+exports.extractKeywords = extractKeywords;
+// 计算两个字符串的简单 Jaccard 相似度（基于字符二元组）
+function jaccardSimilarity(a, b) {
+    const bigrams = (s) => {
+        const bgs = new Set();
+        for (let i = 0; i < s.length - 1; i++)
+            bgs.add(s.substring(i, i + 2));
+        return bgs;
+    };
+    const setA = bigrams(a);
+    const setB = bigrams(b);
+    const intersection = new Set([...setA].filter(x => setB.has(x)));
+    const union = new Set([...setA, ...setB]);
+    return intersection.size / (union.size || 1);
+}
+// 从意图中提取关键词
+function extractKeywords(intent) {
+    return intent.split(/[\s，。！？,]+/).filter(w => w.length > 1).map(w => w.toLowerCase());
+}

package/dist/validator.js

@@ -0,0 +1,196 @@
+"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.validateAction = validateAction;
+exports.validateActionSequence = validateActionSequence;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function loadIR() {
+    const irPath = path.resolve(__dirname, "../ir.json");
+    if (!fs.existsSync(irPath))
+        return [];
+    return JSON.parse(fs.readFileSync(irPath, "utf-8"));
+}
+const BUILTIN_WHITELIST = new Set([
+    "console.log", "setTimeout", "setInterval", "clearTimeout",
+    "JSON.stringify", "JSON.parse", "fetch"
+]);
+function normalizeType(type) {
+    if (!type)
+        return "any";
+    const t = type.toLowerCase().trim();
+    if (t === "string")
+        return "str";
+    if (t === "number" || t === "integer")
+        return "int";
+    if (t === "boolean")
+        return "bool";
+    if (t === "dictionary" || t === "record" || t === "dict")
+        return "dict";
+    if (t === "list")
+        return "list";
+    if (t === "tuple")
+        return "tuple";
+    if (t === "set")
+        return "set";
+    if (t === "any" || t === "variable")
+        return "any";
+    return t;
+}
+function checkVariableFlow(actions) {
+    const errors = [];
+    const declared = new Map();
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions[i];
+        if (action.kind === "call") {
+            for (const arg of (action.args || [])) {
+                if (typeof arg.value === "string" && /^[a-zA-Z_]\w*$/.test(arg.value)) {
+                    if (declared.has(arg.value))
+                        continue;
+                    if (arg.value.length < 15 && arg.value[0] === arg.value[0].toLowerCase()) {
+                        continue;
+                    }
+                }
+            }
+            if (action.assignTo) {
+                if (action.args?.some(a => a.value === action.assignTo)) {
+                    errors.push(`变量 '${action.assignTo}' 在动作${i}中引用自身`);
+                }
+                declared.set(action.assignTo, "any");
+            }
+        }
+        else if (action.kind === "assign") {
+            if (action.target) {
+                if (typeof action.value === "string" && /^[a-zA-Z_]\w*$/.test(action.value)) {
+                    if (!declared.has(action.value) && action.value.length < 15)
+                        continue;
+                    if (!declared.has(action.value))
+                        errors.push(`赋值时引用未定义变量 '${action.value}'`);
+                }
+                declared.set(action.target, "any");
+            }
+        }
+        else if (action.kind === "return") {
+            if (typeof action.value === "string" && /^[a-zA-Z_]\w*$/.test(action.value)) {
+                if (!declared.has(action.value) && !/^["']/.test(action.value) && action.value.length < 15)
+                    continue;
+                if (!declared.has(action.value))
+                    errors.push(`返回未定义变量 '${action.value}'`);
+            }
+        }
+        else if (action.kind === "if") {
+            if (typeof action.condition === "string" && declared.has(action.condition))
+                continue;
+            if (typeof action.condition === "string" && /^(true|false)$/.test(action.condition))
+                continue;
+            if (typeof action.condition === "string" && action.condition.length < 10) {
+                // 可能是表达式，放行
+            }
+            else {
+                errors.push(`条件中引用了未定义的变量 '${action.condition}'`);
+            }
+            errors.push(...checkVariableFlow(action.thenActions || []));
+            errors.push(...checkVariableFlow(action.elseActions || []));
+        }
+        else if (action.kind === "for") {
+            errors.push(...checkVariableFlow(action.bodyActions || []));
+        }
+    }
+    return errors;
+}
+function validateAction(action) {
+    const functions = loadIR();
+    const errors = [];
+    if (!action || !["call", "if", "for", "assign", "return"].includes(action.kind)) {
+        errors.push(`无效动作类型: '${action?.kind}'`);
+        return { valid: false, errors };
+    }
+    if (action.kind === "call") {
+        const fn = functions.find((f) => f.name === action.function);
+        if (!fn) {
+            if (action.function && BUILTIN_WHITELIST.has(action.function))
+                return { valid: true, errors: [] };
+            errors.push(`函数 '${action.function}' 不存在`);
+            return { valid: false, errors };
+        }
+        if (!action.args) {
+            errors.push(`函数 '${action.function}' 缺少参数列表`);
+            return { valid: false, errors };
+        }
+        if (action.args.length !== fn.params.length) {
+            errors.push(`参数数量不匹配: 期望 ${fn.params.length}, 实际 ${action.args.length}`);
+        }
+        action.args.forEach((arg, i) => {
+            if (!arg) {
+                errors.push(`函数 '${action.function}' 的第${i}个参数为空`);
+                return;
+            }
+            const expected = normalizeType(fn.params[i]?.type);
+            const actual = normalizeType(arg.type);
+            if (actual !== "any" && expected !== "any" && actual !== expected) {
+                errors.push(`类型不匹配: 参数 '${fn.params[i].name}' 期望 ${expected}, 实际 ${actual}`);
+            }
+        });
+    }
+    else if (action.kind === "if") {
+        if (action.thenActions) {
+            for (const a of action.thenActions)
+                errors.push(...validateAction(a).errors);
+        }
+        if (action.elseActions) {
+            for (const a of action.elseActions)
+                errors.push(...validateAction(a).errors);
+        }
+    }
+    else if (action.kind === "for") {
+        if (action.bodyActions) {
+            for (const a of action.bodyActions)
+                errors.push(...validateAction(a).errors);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+function validateActionSequence(actions) {
+    const errors = [];
+    for (const action of actions) {
+        const result = validateAction(action);
+        if (!result.valid)
+            errors.push(...result.errors);
+    }
+    if (errors.length === 0) {
+        errors.push(...checkVariableFlow(actions));
+    }
+    return { valid: errors.length === 0, errors };
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "progmune-runtime",
+  "version": "2.0.0",
+  "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
+  "main": "dist/mcp-server.mjs",
+  "bin": {
+    "progmune-runtime": "./dist/mcp-server.mjs"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/mcp-server.mjs"
+  },
+  "keywords": ["program-synthesis", "verification", "mcp", "compiler", "runtime", "immunology"],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "openai": "^6.36.0",
+    "ts-morph": "^28.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": false,
+    "strict": true,
+    "types": ["node"],
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test-*", "*.ts"]
+}