progmune-runtime 2.1.5 → 2.1.6

package/dist/strategy-planner.js

@@ -13,6 +13,7 @@ exports.selectCapabilityChains = selectCapabilityChains;
 exports.formatChainHint = formatChainHint;
 const utils_1 = require("./utils");
 const feedback_1 = require("./feedback");
+const semantic_topology_1 = require("./semantic-topology");
 /** Build a capability graph from IR functions. */
 function buildCapabilityGraph(ir) {
     const graph = new Map();
@@ -25,60 +26,129 @@ function buildCapabilityGraph(ir) {
             tags: f.tags || [],
             requires: f.requires || [],
             produces: f.produces || [],
+            useWhen: f.useWhen || [],
             score: 0,
         });
     }
     return graph;
 }
-/** Score a capability node against an intent. */
+/** Score a capability node against an intent.
+ *  Returns 0 for irrelevant nodes (no keyword match at all). */
 function scoreNode(node, intentLower, keywords) {
     let score = 0;
+    let hasMatch = false;
     // Name match
     for (const kw of keywords) {
-        if (node.name.toLowerCase().includes(kw))
+        if (node.name.toLowerCase().includes(kw)) {
             score += 1;
-        score += (0, utils_1.jaccardSimilarity)(node.name.toLowerCase(), kw);
+            hasMatch = true;
+        }
+        const js = (0, utils_1.jaccardSimilarity)(node.name.toLowerCase(), kw);
+        if (js > 0.2) {
+            score += js;
+            hasMatch = true;
+        }
     }
     // Purpose match
     const purposeLower = node.purpose.toLowerCase();
     for (const kw of keywords) {
-        if (purposeLower.includes(kw))
+        if (purposeLower.includes(kw)) {
             score += 2;
+            hasMatch = true;
+        }
     }
     // Tag match
     for (const tag of node.tags) {
-        if (intentLower.includes(tag.toLowerCase()))
+        if (intentLower.includes(tag.toLowerCase())) {
             score += 1.5;
+            hasMatch = true;
+        }
     }
     // Semantic word overlap in purpose
     const intentWords = intentLower.split(/[\s,，]+/);
     for (const w of intentWords) {
-        if (w.length > 2 && purposeLower.includes(w))
+        if (w.length > 2 && purposeLower.includes(w)) {
             score += 0.5;
+            hasMatch = true;
+        }
     }
+    // useWhen scenario match
+    if (node.useWhen) {
+        for (const scenario of node.useWhen) {
+            const scenarioWords = scenario.toLowerCase().split(/[\s,]+/);
+            const matchCount = scenarioWords.filter((w) => w.length > 3 && intentLower.includes(w)).length;
+            if (matchCount >= 2) {
+                score += 3.0;
+                hasMatch = true;
+            }
+            else if (matchCount === 1) {
+                score += 1.0;
+                hasMatch = true;
+            }
+        }
+    }
+    // Require at least one match to be relevant
+    if (!hasMatch)
+        return 0;
     // Dynamic Credit: multiply by actual success rate
     const successRate = (0, feedback_1.getFailureAdjustedCredit)(node.name);
     const creditFactor = 0.3 + successRate * 0.7;
     return score * creditFactor;
 }
-/** Find all capability nodes that produce a given capability label. */
-function findProducers(graph, capability) {
+/** Find all capability nodes that produce a given capability label.
+ *  Falls back to topology similarity if no direct data-flow match. */
+function findProducers(graph, capability, allNodes) {
     const producers = [];
     for (const node of graph.values()) {
         if (node.produces.some(p => p === capability || capability.includes(p) || p.includes(capability))) {
             producers.push(node);
         }
     }
+    // Topology fallback: find semantically related producers
+    if (producers.length === 0) {
+        try {
+            const topo = (0, semantic_topology_1.getTopology)();
+            for (const node of allNodes) {
+                if (node.produces.length > 0) {
+                    for (const p of node.produces) {
+                        if (topo.capabilityMatch(p, capability) && !producers.includes(node)) {
+                            producers.push(node);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+    }
     return producers;
 }
-/** Find all capability nodes that require a given capability label. */
-function findConsumers(graph, capability) {
+/** Find all capability nodes that require a given capability label.
+ *  Falls back to topology similarity if no direct data-flow match. */
+function findConsumers(graph, capability, allNodes) {
     const consumers = [];
     for (const node of graph.values()) {
         if (node.requires.some(r => r === capability || capability.includes(r) || r.includes(capability))) {
             consumers.push(node);
         }
     }
+    // Topology fallback
+    if (consumers.length === 0) {
+        try {
+            const topo = (0, semantic_topology_1.getTopology)();
+            for (const node of allNodes) {
+                if (node.requires.length > 0) {
+                    for (const r of node.requires) {
+                        if (topo.capabilityMatch(capability, r) && !consumers.includes(node)) {
+                            consumers.push(node);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+    }
     return consumers;
 }
 /**
@@ -98,39 +168,70 @@ function selectCapabilityChains(intent, ir, maxChains = 5) {
     for (const node of graph.values()) {
         node.score = scoreNode(node, intentLower, keywords);
     }
-    // Find seed nodes: highest-scoring nodes that produce something
-    const seeds = [...graph.values()]
-        .filter(n => n.produces.length > 0 && n.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, 10);
+    // Dynamic threshold: tighten for large IR to prevent score dilution
+    let dynamicThreshold = graph.size > 500 ? 2.0 : graph.size > 200 ? 1.5 : 1.0;
+    // Fallback: if no seeds found, halve threshold
+    let seeds = [...graph.values()]
+        .filter(n => n.score > dynamicThreshold && (n.produces.length > 0 || n.score > dynamicThreshold + 2))
+        .sort((a, b) => b.score - a.score);
+    if (seeds.length === 0 && dynamicThreshold > 0.5) {
+        dynamicThreshold *= 0.5;
+        seeds = [...graph.values()]
+            .filter(n => n.score > dynamicThreshold && (n.produces.length > 0 || n.score > dynamicThreshold + 1))
+            .sort((a, b) => b.score - a.score);
+    }
+    seeds = seeds.slice(0, graph.size > 500 ? 30 : 15);
+    const allNodes = [...graph.values()];
     const chains = [];
     for (const seed of seeds) {
         // Build chain: seed → consumer → consumer...
         const chain = [seed];
         const visited = new Set([seed.name]);
         let totalScore = seed.score;
-        // Forward trace: for each produce of the last node, find consumers
+        // Forward trace: data flow → semantic leap
         let current = seed;
         let extended = true;
+        let leapDecay = 1.0; // weight decay for semantic leaps
         while (extended && chain.length < 8) {
             extended = false;
+            // Strategy 1: direct data flow (produces → requires)
             for (const p of current.produces) {
-                const consumers = findConsumers(graph, p).filter(c => !visited.has(c.name));
+                const consumers = findConsumers(graph, p, allNodes).filter(c => !visited.has(c.name));
                 if (consumers.length > 0) {
-                    // Pick best-scoring consumer
                     const bestConsumer = consumers.sort((a, b) => b.score - a.score)[0];
                     chain.push(bestConsumer);
                     visited.add(bestConsumer.name);
                     totalScore += bestConsumer.score;
                     current = bestConsumer;
                     extended = true;
+                    leapDecay = 1.0; // reset decay on direct match
                     break;
                 }
             }
+            // Strategy 2: semantic leap — use topology similarity
+            if (!extended) {
+                try {
+                    const topo = (0, semantic_topology_1.getTopology)();
+                    const similar = topo.findSimilar(current.name, 10)
+                        .filter(s => !visited.has(s.name) && s.similarity > 0.2);
+                    if (similar.length > 0) {
+                        const bestMatch = graph.get(similar[0].name);
+                        if (bestMatch && bestMatch.score > 0) {
+                            chain.push(bestMatch);
+                            visited.add(bestMatch.name);
+                            totalScore += bestMatch.score * leapDecay; // decayed score
+                            current = bestMatch;
+                            extended = true;
+                            leapDecay *= 0.7; // each semantic leap loses 30% weight
+                        }
+                    }
+                }
+                catch { }
+            }
         }
         // Backward trace: does seed need something? Find producers.
         if (seed.requires.length > 0) {
-            const producers = findProducers(graph, seed.requires[0])
+            const producers = findProducers(graph, seed.requires[0], allNodes)
                 .filter(p => !visited.has(p.name));
             if (producers.length > 0) {
                 const bestProducer = producers.sort((a, b) => b.score - a.score)[0];

package/package.json

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