progmune-runtime 2.1.4 → 2.1.6

package/dist/memory-layer.js

@@ -37,6 +37,7 @@ exports.WorkMemory = void 0;
 exports.recordEpisode = recordEpisode;
 exports.getRecentEpisodes = getRecentEpisodes;
 exports.getSuccessfulEpisodes = getSuccessfulEpisodes;
+exports.pruneEpisodicMemory = pruneEpisodicMemory;
 exports.consolidateSemantic = consolidateSemantic;
 exports.findSemanticTemplate = findSemanticTemplate;
 const fs = __importStar(require("fs"));
@@ -100,10 +101,14 @@ function recordEpisode(episode) {
         timestamp: new Date().toISOString(),
     };
     episodes.unshift(newEpisode);
-    if (episodes.length > MAX_EPISODES) {
+    // Simple cap: trim to prevent runaway growth between GC cycles
+    if (episodes.length > MAX_EPISODES * 1.5) {
         episodes.length = MAX_EPISODES;
     }
     saveEpisodes(episodes);
+    // Run GC every 100 episodes
+    if (episodes.length % 100 === 0)
+        pruneEpisodicMemory();
 }
 /** @requires LIMIT @produces EPISODE_LIST */
 function getRecentEpisodes(limit = 10) {
@@ -112,6 +117,35 @@ function getRecentEpisodes(limit = 10) {
 function getSuccessfulEpisodes(limit = 10) {
     return loadEpisodes().filter(e => e.success).slice(0, limit);
 }
+// ── Semantic GC: prune episodic memory ──
+const MAX_EPISODE_COUNT = 1000;
+const MAX_AGE_DAYS = 30;
+/** Prune episodic memory: keep high-value, recent, diverse episodes.
+ *  Removes: old failures (>30 days), low-value duplicates, excess beyond max.
+ *  Called periodically after recording new episodes. */
+function pruneEpisodicMemory() {
+    const episodes = loadEpisodes();
+    if (episodes.length <= MAX_EPISODE_COUNT)
+        return 0;
+    const now = Date.now();
+    const scored = episodes.map((ep, i) => {
+        const ageDays = (now - new Date(ep.timestamp).getTime()) / 86400000;
+        // Score: success=+2, recent=+3, older=-1/day
+        let score = ep.success ? 2 : 0;
+        score += Math.max(0, 3 - ageDays * 0.5); // recent bonus, decays over 6 days
+        score -= Math.max(0, (ageDays - MAX_AGE_DAYS) * 0.5); // penalty for >30 days
+        return { ep, score, index: i };
+    });
+    // Keep top MAX_EPISODES by score
+    scored.sort((a, b) => b.score - a.score);
+    const kept = scored.slice(0, MAX_EPISODE_COUNT).sort((a, b) => a.index - b.index);
+    const removed = episodes.length - kept.length;
+    if (removed > 0) {
+        saveEpisodes(kept.map(s => s.ep));
+        console.error(`[Memory] Semantic GC: removed ${removed} low-value episodes, kept ${kept.length}`);
+    }
+    return removed;
+}
 const SEMANTIC_FILE = path.join(MEMORY_DIR, "semantic.json");
 const SEMANTIC_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 天
 function loadSemantic() {
@@ -174,18 +208,28 @@ function consolidateSemantic(minOccurrences = 3) {
     saveSemantic(templates);
     console.error(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
 }
-/** @requires INTENT @produces TEMPLATE */
+/** @requires INTENT @produces TEMPLATE
+ *  Uses keyword overlap (replaces prefix matching) for semantic recall. */
 function findSemanticTemplate(intent) {
     const templates = loadSemantic();
     if (templates.length === 0)
         return undefined;
-    const prefix = intent.substring(0, 20).toLowerCase();
-    const exactMatch = templates.find(t => t.intentPattern.toLowerCase() === prefix);
-    if (exactMatch && exactMatch.successRate >= 0.7)
-        return exactMatch;
-    const fuzzyMatch = templates.find(t => {
-        const pattern = t.intentPattern.toLowerCase();
-        return (prefix.includes(pattern) || pattern.includes(prefix)) && t.successRate >= 0.8;
-    });
-    return fuzzyMatch;
+    // Extract keywords from intent
+    const words = new Set(intent.toLowerCase().split(/[\s,，]+/).filter(w => w.length > 2));
+    if (words.size === 0)
+        return undefined;
+    // Score templates by keyword overlap
+    let best;
+    let bestScore = 0;
+    for (const t of templates) {
+        const tWords = t.intentPattern.toLowerCase().split(/[\s,，]+/);
+        const shared = tWords.filter(w => words.has(w)).length;
+        const total = new Set([...words, ...new Set(tWords)]).size;
+        const score = shared / (total || 1); // Jaccard-like
+        if (score > 0.5 && t.successRate >= 0.7 && score > bestScore) {
+            bestScore = score;
+            best = t;
+        }
+    }
+    return best;
 }

package/dist/planner.js

@@ -750,6 +750,17 @@ async function plan(userIntent) {
                     score += matchCount * 0.2;
             }
         }
+        // Semantic Capability: useWhen scenario matching
+        if (f.useWhen) {
+            for (const scenario of f.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; // strong signal: intent matches use case
+                else if (matchCount === 1)
+                    score += 1.0;
+            }
+        }
         // Capability Graph: tag match
         if (f.tags) {
             for (const tag of f.tags) {
@@ -758,7 +769,7 @@ async function plan(userIntent) {
             }
         }
         // Dynamic Credit: multiply by actual success rate (0.1-1.0)
-        const successRate = (0, feedback_1.getFunctionSuccessRate)(f.name);
+        const successRate = (0, feedback_1.getFailureAdjustedCredit)(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;

package/dist/session-utils.js

@@ -6,6 +6,7 @@ exports.formatSessionCounts = formatSessionCounts;
  * @requires SESSION_LIST @produces RESOLVED_COUNT
  * @tags session, count, statistics
  */
+/** @useWhen checking how many sessions succeeded; computing success rate */
 function countResolved(sessions) {
     const resolved = sessions.filter((s) => s.resolved).length;
     return { resolved, unresolved: sessions.length - resolved, total: sessions.length };

package/dist/stdlib.js

@@ -32,10 +32,12 @@ exports.retry = retry;
 exports.debounce = debounce;
 // ── String ──
 /** @requires STRING @produces VALIDATION_RESULT @tags string, email, validation */
+/** @useWhen validating user input; form validation; email checking */
 function isValidEmail(str) {
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
 }
 /** @requires STRING @produces TRUNCATED_STRING @tags string, format */
+/** @useWhen displaying preview text; limiting UI output; shortening strings */
 function truncate(str, maxLen, ellipsis = "...") {
     return str.length <= maxLen ? str : str.slice(0, maxLen - ellipsis.length) + ellipsis;
 }
@@ -88,6 +90,7 @@ function arrayDiff(a, b) {
 }
 // ── Math ──
 /** @requires NUMBERS @produces AVERAGE @tags math, statistics */
+/** @useWhen computing statistics; data analysis; metrics calculation */
 function average(nums) {
     return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
 }

package/dist/strategy-planner.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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();
@@ -24,57 +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;
+        }
     }
-    return score;
+    // 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;
 }
 /**
@@ -94,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.4",
+  "version": "2.1.6",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {