progmune-runtime 2.1.3 → 2.1.4

package/dist/planner.js

@@ -39,6 +39,7 @@ const runtime_types_1 = require("./runtime-types");
 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");
@@ -46,6 +47,7 @@ const ssg_validator_1 = require("./ssg-validator");
 const protocol_registry_1 = require("./protocol-registry");
 const semantic_snapshot_1 = require("./semantic-snapshot");
 const strategy_planner_1 = require("./strategy-planner");
+const semantic_topology_1 = require("./semantic-topology");
 const fs = __importStar(require("fs"));
 function enrichActions(actions, ir) {
     return actions.map(a => {
@@ -119,17 +121,20 @@ function buildCompactFuncList(funcs, allFuncs) {
     }).join("\n");
 }
 /** Semantic matching: check if two capability labels are related.
- *  Uses exact match, substring, and Jaccard similarity. */
+ *  Uses SemanticTopology (structural graph) instead of string matching. */
 function semanticMatch(a, b) {
+    try {
+        const topo = (0, semantic_topology_1.getTopology)();
+        if (topo.size > 0)
+            return topo.capabilityMatch(a, b);
+    }
+    catch { }
+    // Fallback: exact + substring
     if (a === b)
         return true;
     if (a.includes(b) || b.includes(a))
         return true;
-    // Fuzzy: shared word prefix (e.g. FAILURE_LIST ↔ FAILURE_DATA)
-    const aWords = a.split("_");
-    const bWords = b.split("_");
-    const shared = aWords.filter(w => bWords.some(bw => bw.includes(w) || w.includes(bw)));
-    return shared.length >= 1 && aWords.length <= 3 && bWords.length <= 3;
+    return false;
 }
 /** Build capability chain hints from IR: producer→consumer relationships.
  *  Uses semantic matching for fuzzy capability linking. */
@@ -551,6 +556,11 @@ async function plan(userIntent) {
     const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
     // Support both old (array) and new ({typeMap, functions}) formats
     const ir = Array.isArray(irRaw) ? irRaw : (irRaw.functions || []);
+    // P1: Build Semantic Topology (once per plan call, cached)
+    try {
+        (0, semantic_topology_1.rebuildTopology)(ir);
+    }
+    catch { }
     // Helper: wrap actions into PlanResult
     let repairMetrics = { applied: false, count: 0, branchIds: [] };
     const wrapResult = (actions, repair) => ({
@@ -747,6 +757,11 @@ async function plan(userIntent) {
                     score += 0.8;
             }
         }
+        // Dynamic Credit: multiply by actual success rate (0.1-1.0)
+        const successRate = (0, feedback_1.getFunctionSuccessRate)(f.name);
+        const creditFactor = 0.3 + successRate * 0.7; // range: 0.3 (always fail) to 1.0 (always succeed)
+        if (f.exported && !f.external)
+            score *= creditFactor;
         return { ...f, score };
     });
     scored.sort((a, b) => b.score - a.score);
@@ -956,6 +971,17 @@ ${RETRY_HINT}
                 }
             }
         }
+        // P0: Strategy Enforcement — LLM must follow recommended chain
+        if (chains.length > 0 && chains[0].nodes.length >= 2) {
+            const topChain = chains[0];
+            const requiredFuncs = topChain.nodes.map(n => n.name);
+            const chosenFuncs = filtered.filter(a => a.kind === "call").map(a => a.function);
+            const missing = requiredFuncs.filter(fn => !chosenFuncs.includes(fn));
+            if (missing.length >= requiredFuncs.length * 0.5) {
+                // More than 50% of the chain is missing — LLM ignored the strategy
+                preCheckErrors.push(`策略违规: 推荐链 ${topChain.explanation}，但缺少 ${missing.join(", ")}`);
+            }
+        }
         // 1) 基础序列校验
         const seqResult = (0, validator_1.validateActionSequence)(filtered);
         if (!seqResult.valid || preCheckErrors.length > 0) {

package/dist/semantic-topology.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Phase 8: Semantic Topology (P1)
+ *
+ * Builds a similarity graph from IR structural data:
+ *   - File co-occurrence (functions in same file are related)
+ *   - Tag overlap (shared domain tags)
+ *   - Purpose word overlap (Jaccard on purpose text)
+ *   - Chain adjacency (producer→consumer links)
+ *
+ * Replaces simple string matching in capability search.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticTopology = void 0;
+exports.getTopology = getTopology;
+exports.rebuildTopology = rebuildTopology;
+class SemanticTopology {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.similarityCache = new Map();
+    }
+    /** Build topology from IR data */
+    build(ir) {
+        this.nodes.clear();
+        this.edges.clear();
+        this.similarityCache.clear();
+        // 1. Create nodes
+        for (const f of ir) {
+            if (!f.exported && !f.external)
+                continue;
+            this.nodes.set(f.name, {
+                name: f.name,
+                file: f.file || "",
+                tags: new Set((f.tags || []).map((t) => t.toLowerCase())),
+                purposeWords: new Set((f.purpose || "").toLowerCase().split(/[\s,，]+/).filter((w) => w.length > 2)),
+                produces: new Set(f.produces || []),
+                requires: new Set(f.requires || []),
+            });
+        }
+        // 2. Build edges: file co-occurrence
+        const byFile = new Map();
+        for (const [name, node] of this.nodes) {
+            if (!byFile.has(node.file))
+                byFile.set(node.file, []);
+            byFile.get(node.file).push(name);
+        }
+        for (const names of byFile.values()) {
+            for (let i = 0; i < names.length; i++) {
+                for (let j = i + 1; j < names.length; j++) {
+                    this.addEdge(names[i], names[j], 0.3, "co-file");
+                }
+            }
+        }
+        // 3. Build edges: tag overlap
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const [nameB, nodeB] of this.nodes) {
+                if (nameA >= nameB)
+                    continue;
+                const tagOverlap = [...nodeA.tags].filter(t => nodeB.tags.has(t)).length;
+                if (tagOverlap > 0) {
+                    const maxTags = Math.max(nodeA.tags.size, nodeB.tags.size) || 1;
+                    this.addEdge(nameA, nameB, 0.4 * (tagOverlap / maxTags), "tag");
+                }
+            }
+        }
+        // 4. Build edges: purpose word overlap
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const [nameB, nodeB] of this.nodes) {
+                if (nameA >= nameB)
+                    continue;
+                const shared = [...nodeA.purposeWords].filter(w => nodeB.purposeWords.has(w)).length;
+                const total = [...new Set([...nodeA.purposeWords, ...nodeB.purposeWords])].length || 1;
+                const jaccard = shared / total;
+                if (jaccard > 0.15) {
+                    this.addEdge(nameA, nameB, 0.5 * jaccard, "purpose");
+                }
+            }
+        }
+        // 5. Build edges: chain adjacency (producer→consumer)
+        for (const [nameA, nodeA] of this.nodes) {
+            for (const p of nodeA.produces) {
+                for (const [nameB, nodeB] of this.nodes) {
+                    if (nameA === nameB)
+                        continue;
+                    if (nodeB.requires.has(p)) {
+                        this.addEdge(nameA, nameB, 0.7, `chain:${p}`);
+                    }
+                    // Fuzzy chain: substring match
+                    for (const r of nodeB.requires) {
+                        if (p.includes(r) || r.includes(p)) {
+                            this.addEdge(nameA, nameB, 0.4, `fuzzy:${p}≈${r}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    addEdge(a, b, weight, reason) {
+        const key = a < b ? `${a}::${b}` : `${b}::${a}`;
+        if (!this.edges.has(a))
+            this.edges.set(a, []);
+        if (!this.edges.has(b))
+            this.edges.set(b, []);
+        this.edges.get(a).push({ source: a, target: b, weight, reason });
+        this.edges.get(b).push({ source: b, target: a, weight, reason });
+        this.similarityCache.set(key, Math.max(this.similarityCache.get(key) || 0, weight));
+    }
+    /** Get similarity between two functions (0-1). */
+    similarity(funcA, funcB) {
+        if (funcA === funcB)
+            return 1.0;
+        const key = funcA < funcB ? `${funcA}::${funcB}` : `${funcB}::${funcA}`;
+        return this.similarityCache.get(key) || 0;
+    }
+    /** Find top N most similar functions to a given function. */
+    findSimilar(funcName, topN = 5) {
+        const edges = this.edges.get(funcName) || [];
+        return edges
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, topN)
+            .map(e => ({ name: e.target, similarity: e.weight }));
+    }
+    /** Semantic match: two capability labels are related via topology. */
+    capabilityMatch(produce, require) {
+        // Direct match
+        if (produce === require)
+            return true;
+        if (produce.includes(require) || require.includes(produce))
+            return true;
+        // Topology check: are there functions producing 'produce' that are connected
+        // to functions requiring 'require'?
+        const producers = [...this.nodes.values()].filter(n => n.produces.has(produce));
+        const consumers = [...this.nodes.values()].filter(n => n.requires.has(require));
+        for (const p of producers) {
+            for (const c of consumers) {
+                if (this.similarity(p.name, c.name) > 0.2)
+                    return true;
+            }
+        }
+        return false;
+    }
+    /** Get node count */
+    get size() { return this.nodes.size; }
+}
+exports.SemanticTopology = SemanticTopology;
+// Singleton
+let _topology = null;
+function getTopology(ir) {
+    if (!_topology && ir) {
+        _topology = new SemanticTopology();
+        _topology.build(ir);
+    }
+    return _topology || new SemanticTopology();
+}
+function rebuildTopology(ir) {
+    _topology = new SemanticTopology();
+    _topology.build(ir);
+    return _topology;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {