@jack200714/mafw 4.5.1

package/gateway/dist/core/compression/session-pruner.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionPruner = void 0;
+/**
+ * Session Pruner — L1 实时剪枝器
+ *
+ * 职责：Session 过长时自动压缩历史内容，保留当前 Wave 完整上下文。
+ *
+ * 策略（从文档 §3.1 提取）：
+ *   ┌──────────────┬─────────────┬──────────────┬────────────┐
+ *   │ 内容类型      │ 当前 Wave   │ 已完成 Wave  │ 处理方式   │
+ *   ├──────────────┼─────────────┼──────────────┼────────────┤
+ *   │ System Prompt │ 完整保留    │ 完整保留    │ 不可压缩   │
+ *   │ Parametric Δ  │ 完整保留    │ 完整保留    │ 不可压缩   │
+ *   │ Task 定义     │ 完整保留    │ 摘要        │ 保留ID+状态│
+ *   │ 代码编辑      │ 完整保留    │ 摘要        │ 保留路径   │
+ *   │ 工具输出      │ 完整保留    │ 截断        │ 最后10行   │
+ *   │ 对话历史      │ 完整保留    │ 压缩        │ Wave摘要   │
+ *   │ 成功测试日志  │ 完整保留    │ 丢弃        │ 只保留标记 │
+ *   │ 失败测试日志  │ 完整保留    │ 完整保留    │ 不压缩     │
+ *   └──────────────┴─────────────┴──────────────┴────────────┘
+ *
+ * 触发条件：Session 达到 6000 tokens (75% 压缩阈值) 时触发
+ */
+class SessionPruner {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            maxContextTokens: 8000,
+            compressionThreshold: 0.6, // 4800 tokens
+            currentWaveReserve: 2000,
+            toolOutputReserve: 10,
+            ...config
+        };
+    }
+    /**
+     * 检查是否需要剪枝
+     */
+    shouldPrune(currentTokens) {
+        return currentTokens >= this.config.maxContextTokens * this.config.compressionThreshold;
+    }
+    /**
+     * 执行剪枝：将已完成 Wave 的内容压缩为摘要
+     */
+    prune(session, currentWaveId, completedDigests) {
+        const pruned = [];
+        let currentTokens = 0;
+        for (const item of session) {
+            // 当前 Wave 的内容完整保留
+            if (item.waveId === currentWaveId) {
+                pruned.push(item);
+                currentTokens += this.estimateTokens(item);
+                continue;
+            }
+            // 已完成 Wave 的内容按类型压缩
+            const compressed = this.compressItem(item);
+            if (compressed) {
+                pruned.push(compressed);
+                currentTokens += this.estimateTokens(compressed);
+            }
+        }
+        // 在 Session 开头插入已完成 Wave 的摘要卡片
+        if (completedDigests.length > 0) {
+            const digestBlock = this.renderDigests(completedDigests);
+            pruned.unshift({ type: 'wave_digests', content: digestBlock });
+        }
+        return pruned;
+    }
+    /**
+     * 压缩单个 Session 条目
+     */
+    compressItem(item) {
+        switch (item.type) {
+            case 'system_prompt':
+            case 'parametric_delta':
+            case 'test_log_fail':
+                // 不可压缩
+                return item;
+            case 'task_definition':
+                return {
+                    ...item,
+                    content: `[SUMMARY] Task ${item.taskId}: ${item.status || 'completed'}`,
+                    _compressed: true
+                };
+            case 'code_edit':
+                return {
+                    ...item,
+                    content: `[SUMMARY] ${item.filePath}: ${item.linesChanged || 'changed'}`,
+                    _compressed: true
+                };
+            case 'tool_output':
+                return {
+                    ...item,
+                    content: this.truncateToolOutput(item.content),
+                    _compressed: true
+                };
+            case 'dialogue':
+                // 丢弃对话历史，已包含在 Wave 摘要中
+                return null;
+            case 'test_log_success':
+                // 只保留标记
+                return { type: 'test_log_success', status: 'PASS', _compressed: true };
+            default:
+                return item;
+        }
+    }
+    /**
+     * 工具输出截断：保留最后 N 行
+     */
+    truncateToolOutput(output) {
+        const lines = output.split('\n');
+        if (lines.length <= this.config.toolOutputReserve)
+            return output;
+        const lastLines = lines.slice(-this.config.toolOutputReserve);
+        return `[TRUNCATED: ${lines.length} lines → last ${this.config.toolOutputReserve}]\n${lastLines.join('\n')}`;
+    }
+    /**
+     * 渲染 Wave 摘要卡片
+     */
+    renderDigests(digests) {
+        const lines = ['[WAVE_DIGESTS COMPLETED]'];
+        for (const d of digests) {
+            lines.push(`[WAVE_DIGEST id=${d.id} status=${d.status} tokens_saved=${d.tokens_saved}]`, `  domain: ${d.domain}`, `  completed_tasks: [${d.completed_tasks.join(', ')}]`, `  key_decisions: [${d.key_decisions.join(', ')}]`, `  blockers: [${d.blockers.join(', ')}]`, `  files_changed: [${d.files_changed.join(', ')}]`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 粗略 token 估算
+     */
+    estimateTokens(item) {
+        const text = typeof item === 'string' ? item : JSON.stringify(item);
+        const chineseChars = (text.match(/[\u4e00-\u9fff]/g) || []).length;
+        const englishWords = text.split(/\s+/).filter(w => /[a-zA-Z]/.test(w)).length;
+        return Math.ceil(chineseChars + englishWords * 0.75);
+    }
+}
+exports.SessionPruner = SessionPruner;

package/gateway/dist/core/compression/token-budget-allocator.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenBudgetAllocator = void 0;
+class TokenBudgetAllocator {
+    defaultBudget;
+    allocations;
+    useWatermark;
+    constructor(config) {
+        this.defaultBudget = config?.defaultBudget ?? 8000;
+        this.useWatermark = !config?.allocations;
+        this.allocations = {
+            parametric: 0.25,
+            procedural: 0.20,
+            semantic: 0.30,
+            episodic: 0.15,
+            buffer: 0.10,
+            ...config?.allocations
+        };
+    }
+    allocate(memories, totalBudget, model) {
+        const budget = totalBudget ?? this.defaultBudget;
+        const compressPct = model === 'haiku' ? 0.5 : 1.0;
+        const order = ['parametric', 'procedural', 'semantic', 'episodic'];
+        const selected = { parametric: [], procedural: [], semantic: [], episodic: [] };
+        let totalUsed = 0;
+        const unselected = [];
+        if (!this.useWatermark) {
+            // Legacy percentage-based allocation
+            for (const category of order) {
+                const catBudget = Math.floor(budget * (this.allocations[category] ?? 0));
+                const items = [...(memories[category] ?? [])];
+                items.sort((a, b) => {
+                    const ea = typeof a.energy === 'number' ? a.energy : 0;
+                    const eb = typeof b.energy === 'number' ? b.energy : 0;
+                    return eb - ea;
+                });
+                let remaining = catBudget;
+                for (const item of items) {
+                    const tokens = this.estimateItemTokens(item, category);
+                    if (tokens <= remaining) {
+                        selected[category].push(item);
+                        remaining -= tokens;
+                    }
+                    else {
+                        unselected.push({ item, category });
+                    }
+                }
+                totalUsed += catBudget - remaining;
+            }
+            // Buffer fill: recycle unused budget across all categories
+            let buf = Math.floor(budget * (this.allocations.buffer ?? 0));
+            for (const category of order) {
+                const catBudget = Math.floor(budget * (this.allocations[category] ?? 0));
+                const catUsed = selected[category].reduce((sum, item) => sum + this.estimateItemTokens(item, category), 0);
+                buf += catBudget - catUsed;
+            }
+            unselected.sort((a, b) => {
+                const ea = typeof a.item.energy === 'number' ? a.item.energy : 0;
+                const eb = typeof b.item.energy === 'number' ? b.item.energy : 0;
+                return eb - ea;
+            });
+            for (const { item, category } of unselected) {
+                const tokens = this.estimateItemTokens(item, category);
+                if (tokens <= buf) {
+                    selected[category].push(item);
+                    buf -= tokens;
+                    totalUsed += tokens;
+                }
+            }
+            return {
+                parametric: selected.parametric,
+                procedural: selected.procedural,
+                semantic: selected.semantic,
+                episodic: selected.episodic,
+                totalTokens: totalUsed
+            };
+        }
+        // Dynamic watermark mode
+        const watermark = {
+            p0: { budget: Math.min(3000, budget * 0.20), key: 'parametric' },
+            p1: { budget: Math.min(5000, budget * 0.35), key: 'procedural' },
+            p2: { budget: Math.min(4000, budget * 0.30) * compressPct, key: 'semantic' },
+            p3: { budget: Math.min(2000, budget * 0.15) * compressPct, key: 'episodic' }
+        };
+        for (const cat of order) {
+            let catItems = [...(memories[cat] ?? [])];
+            catItems.sort((a, b) => {
+                const ea = typeof a.energy === 'number' ? a.energy : 0;
+                const eb = typeof b.energy === 'number' ? b.energy : 0;
+                return eb - ea;
+            });
+            const catBudget = this.getWatermarkBudget(watermark, cat);
+            let remaining = catBudget;
+            for (const item of catItems) {
+                const tokens = this.estimateItemTokens(item, cat);
+                if (tokens <= remaining) {
+                    selected[cat].push(item);
+                    remaining -= tokens;
+                }
+            }
+            totalUsed += catBudget - remaining;
+        }
+        return {
+            parametric: selected.parametric,
+            procedural: selected.procedural,
+            semantic: selected.semantic,
+            episodic: selected.episodic,
+            totalTokens: totalUsed,
+            p0Budget: watermark.p0.budget,
+            p1Budget: watermark.p1.budget,
+            p2Budget: watermark.p2.budget,
+            p3Budget: watermark.p3.budget
+        };
+    }
+    getWatermarkBudget(watermark, category) {
+        for (const [, v] of Object.entries(watermark)) {
+            const entry = v;
+            if (entry.key === category)
+                return entry.budget;
+        }
+        return 0;
+    }
+    estimateItemTokens(item, category) {
+        switch (category) {
+            case 'parametric':
+                return Math.ceil((item.content || item.rule || '').length / 4) + 10;
+            case 'procedural':
+                return Math.ceil((item.pattern || '').length / 4) + 15;
+            case 'semantic':
+                return Math.ceil((item.facts || []).join(' ').length / 4) + 20;
+            case 'episodic':
+                return Math.ceil((item.summary || item.content || '').length / 4) + 10;
+            default:
+                return 50;
+        }
+    }
+    setDefaultBudget(budget) {
+        this.defaultBudget = budget;
+    }
+}
+exports.TokenBudgetAllocator = TokenBudgetAllocator;

package/gateway/dist/core/compression/vector-index.js

@@ -0,0 +1,117 @@
+"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.VectorIndex = void 0;
+const fs = __importStar(require("fs"));
+const transformers_1 = require("@huggingface/transformers");
+class VectorIndex {
+    embedder = null;
+    vectors = new Map();
+    initialized = false;
+    modelName;
+    constructor(modelName) {
+        this.modelName = modelName || 'Xenova/all-MiniLM-L6-v2';
+    }
+    async init() {
+        this.embedder = await (0, transformers_1.pipeline)('feature-extraction', this.modelName);
+        this.initialized = true;
+    }
+    async addDocument(id, text, metadata) {
+        if (!this.initialized)
+            await this.init();
+        const vector = await this.embed(text);
+        this.vectors.set(id, { vector, text, metadata });
+    }
+    async addDocuments(entries) {
+        for (const entry of entries) {
+            await this.addDocument(entry.id, entry.text, entry.metadata);
+        }
+    }
+    async search(query, topK) {
+        if (!this.initialized)
+            await this.init();
+        topK = topK || 10;
+        if (this.vectors.size === 0)
+            return [];
+        const queryVector = await this.embed(query);
+        const scored = [];
+        for (const [id, entry] of this.vectors) {
+            const score = this.cosineSimilarity(queryVector, entry.vector);
+            scored.push({ id, score, text: entry.text, metadata: entry.metadata });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
+    removeDocument(id) {
+        this.vectors.delete(id);
+    }
+    clear() {
+        this.vectors.clear();
+    }
+    get size() {
+        return this.vectors.size;
+    }
+    save(path) {
+        const obj = {};
+        for (const [id, entry] of this.vectors) {
+            obj[id] = { vector: entry.vector, text: entry.text, metadata: entry.metadata };
+        }
+        fs.writeFileSync(path, JSON.stringify(obj, null, 2), 'utf-8');
+    }
+    load(path) {
+        const raw = fs.readFileSync(path, 'utf-8');
+        const obj = JSON.parse(raw);
+        this.vectors.clear();
+        for (const [id, data] of Object.entries(obj)) {
+            this.vectors.set(id, data);
+        }
+    }
+    async embed(text) {
+        const output = await this.embedder(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+}
+exports.VectorIndex = VectorIndex;

package/gateway/dist/core/compression/zero-token-compressor.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroTokenCompressor = void 0;
+class ZeroTokenCompressor {
+    rules;
+    constructor() {
+        this.rules = [
+            {
+                pattern: /coverage\s+([\d.]+)%/i,
+                extractor: (match) => ({
+                    type: 'metric',
+                    fact: `coverage ${match[1]}%`,
+                    concept: 'coverage',
+                }),
+            },
+            {
+                pattern: /Error:\s+(.+)/,
+                extractor: (match) => ({
+                    type: 'error',
+                    fact: `Error: ${match[1]}`,
+                    concept: 'error',
+                }),
+            },
+            {
+                pattern: /modified\s+(.+?):\s+(.+)/i,
+                extractor: (match) => ({
+                    type: 'file_change',
+                    fact: `Modified ${match[1]}: ${match[2]}`,
+                    concept: 'file-edit',
+                }),
+            },
+            {
+                pattern: /Tool\s+(\w+)\s+executed/i,
+                extractor: (match) => ({
+                    type: 'tool_use',
+                    fact: `Tool used: ${match[1]}`,
+                    concept: match[1].toLowerCase(),
+                }),
+            },
+        ];
+    }
+    compress(observations) {
+        const results = [];
+        let idCounter = 0;
+        for (const obs of observations) {
+            const content = typeof obs.content === 'string' ? obs.content : '';
+            let matched = false;
+            for (const rule of this.rules) {
+                const match = content.match(rule.pattern);
+                if (match) {
+                    const extracted = rule.extractor(match);
+                    results.push({
+                        id: `compressed_${idCounter++}`,
+                        type: extracted.type,
+                        fact: extracted.fact,
+                        concept: extracted.concept,
+                        energy: 0.5,
+                        timestamp: obs.timestamp || Date.now(),
+                        loopNum: obs.loopNum || 0,
+                    });
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                results.push({
+                    id: `compressed_${idCounter++}`,
+                    type: 'observation',
+                    fact: content.substring(0, 100),
+                    concept: 'misc',
+                    energy: 0.3,
+                    timestamp: obs.timestamp || Date.now(),
+                    loopNum: obs.loopNum || 0,
+                });
+            }
+        }
+        return results;
+    }
+}
+exports.ZeroTokenCompressor = ZeroTokenCompressor;

package/gateway/dist/core/cost/cognitive-router.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitiveRouter = exports.defaultRouterConfig = void 0;
+exports.defaultRouterConfig = {
+    agents: {
+        plan: { model: 'claude-sonnet-4-20250514', priority: 'quality' },
+        execute: { model: 'claude-sonnet-4-20250514', priority: 'quality' },
+        review: { model: 'claude-haiku-3-5-20241022', priority: 'cost' }
+    },
+    budget: { total: 1000000, perGoal: 200000, threshold: 0.8 }
+};
+class CognitiveRouter {
+    config;
+    constructor(config) {
+        this.config = this.mergeConfig(exports.defaultRouterConfig, config);
+    }
+    selectModel(agentType, remainingBudget, totalBudget) {
+        const usage = 1 - (remainingBudget / totalBudget);
+        const agentConfig = this.config.agents[agentType];
+        if (usage > this.config.budget.threshold && agentType === 'execute') {
+            return { model: 'haiku', reason: 'budget_threshold' };
+        }
+        return { model: agentConfig.model, reason: 'default' };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    mergeConfig(base, override) {
+        if (!override)
+            return base;
+        return {
+            agents: {
+                plan: { ...base.agents.plan, ...override.agents?.plan },
+                execute: { ...base.agents.execute, ...override.agents?.execute },
+                review: { ...base.agents.review, ...override.agents?.review }
+            },
+            budget: { ...base.budget, ...override.budget }
+        };
+    }
+}
+exports.CognitiveRouter = CognitiveRouter;

package/gateway/dist/core/cost/cost-estimator.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostEstimator = void 0;
+const types_1 = require("./types");
+class CostEstimator {
+    records = [];
+    recordToolCall(call) {
+        const tokens = (0, types_1.estimateTokens)(call.toolName, call.input);
+        const cost = (0, types_1.estimateCost)(tokens, call.model);
+        const record = {
+            id: (0, types_1.generateCostId)(),
+            goalId: call.goalId,
+            loopNum: call.loopNum,
+            waveNum: call.waveNum,
+            toolName: call.toolName,
+            estimatedTokens: tokens,
+            estimatedCost: cost,
+            timestamp: new Date().toISOString()
+        };
+        this.records.push(record);
+        return record;
+    }
+    getAllRecords() {
+        return [...this.records];
+    }
+    getSummary(goalId, loopNum) {
+        const filtered = this.records.filter(r => {
+            if (goalId && r.goalId !== goalId)
+                return false;
+            if (loopNum !== undefined && r.loopNum !== loopNum)
+                return false;
+            return true;
+        });
+        if (filtered.length === 0) {
+            return { totalTokens: 0, totalCost: 0, byWave: [], byTool: [] };
+        }
+        const waveMap = new Map();
+        for (const r of filtered) {
+            const wn = r.waveNum ?? 0;
+            const entry = waveMap.get(wn) || { tokens: 0, cost: 0 };
+            entry.tokens += r.estimatedTokens;
+            entry.cost += r.estimatedCost;
+            waveMap.set(wn, entry);
+        }
+        const toolMap = new Map();
+        for (const r of filtered) {
+            const entry = toolMap.get(r.toolName) || { tokens: 0, cost: 0 };
+            entry.tokens += r.estimatedTokens;
+            entry.cost += r.estimatedCost;
+            toolMap.set(r.toolName, entry);
+        }
+        return {
+            totalTokens: filtered.reduce((s, r) => s + r.estimatedTokens, 0),
+            totalCost: filtered.reduce((s, r) => s + r.estimatedCost, 0),
+            byWave: Array.from(waveMap.entries()).map(([waveNum, data]) => ({ waveNum, ...data })),
+            byTool: Array.from(toolMap.entries()).map(([toolName, data]) => ({ toolName, ...data }))
+        };
+    }
+    clear() {
+        this.records = [];
+    }
+}
+exports.CostEstimator = CostEstimator;

package/gateway/dist/core/cost/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCostId = generateCostId;
+exports.estimateTokens = estimateTokens;
+exports.estimateCost = estimateCost;
+function generateCostId() {
+    return `cost_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function estimateTokens(toolName, input) {
+    if (['file_edit', 'file_write', 'mafw_observe', 'mafw_search_hybrid'].includes(toolName)) {
+        return 0;
+    }
+    return Math.ceil(input.length / 4);
+}
+function estimateCost(tokens, model = 'sonnet') {
+    const RATES = { sonnet: 0.003, haiku: 0.0015 };
+    const rate = RATES[model] ?? RATES.sonnet;
+    return (tokens / 1000) * rate;
+}