progmune-runtime 2.0.4 → 2.1.1

package/dist/memory-layer.js

@@ -41,7 +41,17 @@ exports.consolidateSemantic = consolidateSemantic;
 exports.findSemanticTemplate = findSemanticTemplate;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const MEMORY_DIR = path.resolve(__dirname, "../.progmune_memory");
+const file_lock_1 = require("./file-lock");
+// 基于项目路径的隔离记忆目录，可通过环境变量 PROGMUNE_MEMORY_DIR 自定义
+// 优先使用 PROGMUNE_PROJECT_DIR（由 MCP 服务器在调用时设置），确保多项目隔离
+const projectDir = process.env.PROGMUNE_PROJECT_DIR || process.cwd();
+const MEMORY_DIR = process.env.PROGMUNE_MEMORY_DIR
+    || path.resolve(projectDir, ".progmune_memory");
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+// ========== 工作记忆 ==========
 class WorkMemory {
     constructor() {
         this.bindings = new Map();
@@ -56,20 +66,32 @@ class WorkMemory {
 exports.WorkMemory = WorkMemory;
 const EPISODIC_FILE = path.join(MEMORY_DIR, "episodic.json");
 const MAX_EPISODES = 50;
-function ensureDir(dir) {
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-}
+const EPISODE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 天
 function loadEpisodes() {
     ensureDir(MEMORY_DIR);
     if (!fs.existsSync(EPISODIC_FILE))
         return [];
-    return JSON.parse(fs.readFileSync(EPISODIC_FILE, "utf-8"));
+    const all = JSON.parse(fs.readFileSync(EPISODIC_FILE, "utf-8"));
+    const cutoff = Date.now() - EPISODE_TTL_MS;
+    const fresh = all.filter(e => new Date(e.timestamp).getTime() > cutoff);
+    if (fresh.length < all.length) {
+        console.error(`[记忆衰减-读取] 过滤了 ${all.length - fresh.length} 条过期情景记忆`);
+        fs.writeFileSync(EPISODIC_FILE, JSON.stringify(fresh, null, 2));
+    }
+    return fresh;
 }
 function saveEpisodes(episodes) {
-    ensureDir(MEMORY_DIR);
-    fs.writeFileSync(EPISODIC_FILE, JSON.stringify(episodes.slice(0, MAX_EPISODES), null, 2));
+    (0, file_lock_1.withLock)("episodic.json", () => {
+        ensureDir(MEMORY_DIR);
+        const cutoff = Date.now() - EPISODE_TTL_MS;
+        const fresh = episodes.filter(e => new Date(e.timestamp).getTime() > cutoff);
+        if (fresh.length !== episodes.length) {
+            console.error(`[记忆衰减-写入] 清理了 ${episodes.length - fresh.length} 条过期情景记忆`);
+        }
+        fs.writeFileSync(EPISODIC_FILE, JSON.stringify(fresh.slice(0, MAX_EPISODES), null, 2));
+    });
 }
+/** @requires EXECUTION_DATA @produces MEMORY_ID */
 function recordEpisode(episode) {
     const episodes = loadEpisodes();
     const newEpisode = {
@@ -78,10 +100,12 @@ function recordEpisode(episode) {
         timestamp: new Date().toISOString(),
     };
     episodes.unshift(newEpisode);
-    if (episodes.length > MAX_EPISODES)
+    if (episodes.length > MAX_EPISODES) {
         episodes.length = MAX_EPISODES;
+    }
     saveEpisodes(episodes);
 }
+/** @requires LIMIT @produces EPISODE_LIST */
 function getRecentEpisodes(limit = 10) {
     return loadEpisodes().slice(0, limit);
 }
@@ -89,15 +113,31 @@ function getSuccessfulEpisodes(limit = 10) {
     return loadEpisodes().filter(e => e.success).slice(0, limit);
 }
 const SEMANTIC_FILE = path.join(MEMORY_DIR, "semantic.json");
+const SEMANTIC_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 天
 function loadSemantic() {
     ensureDir(MEMORY_DIR);
     if (!fs.existsSync(SEMANTIC_FILE))
         return [];
-    return JSON.parse(fs.readFileSync(SEMANTIC_FILE, "utf-8"));
+    const all = JSON.parse(fs.readFileSync(SEMANTIC_FILE, "utf-8"));
+    const cutoff = Date.now() - SEMANTIC_TTL_MS;
+    const fresh = all.filter(t => new Date(t.lastUsedAt).getTime() > cutoff);
+    if (fresh.length < all.length) {
+        console.error(`[记忆衰减-读取] 清理了 ${all.length - fresh.length} 个过期语义模板`);
+        fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(fresh, null, 2));
+    }
+    return fresh;
 }
 function saveSemantic(templates) {
-    ensureDir(MEMORY_DIR);
-    fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(templates, null, 2));
+    (0, file_lock_1.withLock)("semantic.json", () => {
+        ensureDir(MEMORY_DIR);
+        // TTL 衰减：清理超过 30 天未使用的语义模板
+        const cutoff = Date.now() - SEMANTIC_TTL_MS;
+        const fresh = templates.filter(t => new Date(t.lastUsedAt).getTime() > cutoff);
+        if (fresh.length !== templates.length) {
+            console.error(`[记忆衰减] 清理了 ${templates.length - fresh.length} 个过期语义模板`);
+        }
+        fs.writeFileSync(SEMANTIC_FILE, JSON.stringify(fresh, null, 2));
+    });
 }
 function consolidateSemantic(minOccurrences = 3) {
     const episodes = getSuccessfulEpisodes(MAX_EPISODES);
@@ -132,8 +172,9 @@ function consolidateSemantic(minOccurrences = 3) {
         }
     }
     saveSemantic(templates);
-    console.log(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
+    console.error(`[语义记忆] 巩固完成，模板数量: ${templates.length}`);
 }
+/** @requires INTENT @produces TEMPLATE */
 function findSemanticTemplate(intent) {
     const templates = loadSemantic();
     if (templates.length === 0)

package/dist/metrics.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345721473_u5ik3 timestamp=2026-06-01T20:28:42.736Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 387 functions, 17 protocol rules
+const execute_1 = require("./execute");
+function main() {
+    const metrics = (0, execute_1.getExecutionMetrics)();
+    return metrics;
+}
+main();