@jack200714/mafw 4.5.1

package/gateway/dist/core/goal-budget.js

@@ -0,0 +1,63 @@
+"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.mergeBudgetIntoSnapshot = mergeBudgetIntoSnapshot;
+const fs = __importStar(require("fs"));
+/**
+ * 把 goal request 文件里的 budget.{maxTurns,maxCostUsd} 并入 policySnapshot。
+ * fail-open：文件缺失/坏 JSON/无 budget → 原样返回。
+ * 消费方：handleValidate（state 初始化）与 onGoalCreated（policySnapshot 补写），
+ * BudgetGuard（core/budget-guard.ts 挂载链）读 policySnapshot.maxTurns/maxCostUsd 硬停。
+ */
+function mergeBudgetIntoSnapshot(snapshot, requestFile) {
+    try {
+        if (!fs.existsSync(requestFile))
+            return snapshot;
+        const request = JSON.parse(fs.readFileSync(requestFile, 'utf-8'));
+        const budget = request?.budget;
+        const maxTurns = typeof budget?.maxTurns === 'number' ? budget.maxTurns : undefined;
+        const maxCostUsd = typeof budget?.maxCostUsd === 'number' ? budget.maxCostUsd : undefined;
+        if (maxTurns === undefined && maxCostUsd === undefined)
+            return snapshot;
+        return {
+            ...snapshot,
+            ...(maxTurns !== undefined ? { maxTurns } : {}),
+            ...(maxCostUsd !== undefined ? { maxCostUsd } : {}),
+        };
+    }
+    catch {
+        return snapshot;
+    }
+}

package/gateway/dist/core/graph/entity-extractor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityExtractor = void 0;
+class EntityExtractor {
+    conceptPatterns;
+    constructor() {
+        this.conceptPatterns = [
+            /\bjwt\b/gi,
+            /\boauth\b/gi,
+            /\bbcrypt\b/gi,
+            /\bexpress\b/gi,
+            /\breact\b/gi,
+            /\bvue\b/gi,
+            /\bangular\b/gi,
+            /\bauthentication\b/gi,
+            /\bauthorization\b/gi,
+            /\bmiddleware\b/gi,
+            /\bcontroller\b/gi,
+            /\bservice\b/gi,
+            /\bcoverage\b/gi,
+            /\btesting\b/gi,
+            /\bjest\b/gi,
+            /\bmocha\b/gi,
+            /\bcypress\b/gi,
+            /\bapi\b/gi,
+            /\bendpoint\b/gi,
+            /\broute\b/gi,
+            /\bhandler\b/gi,
+        ];
+    }
+    extract(text) {
+        const matches = new Set();
+        for (const pattern of this.conceptPatterns) {
+            const match = text.match(pattern);
+            if (match) {
+                matches.add(match[0].toLowerCase());
+            }
+        }
+        const extPattern = /\.(\w+)\b/g;
+        let extMatch;
+        while ((extMatch = extPattern.exec(text)) !== null) {
+            const ext = extMatch[1].toLowerCase();
+            if (['ts', 'js', 'py', 'go', 'rs', 'java'].includes(ext)) {
+                matches.add(`.${ext}`);
+            }
+        }
+        return Array.from(matches);
+    }
+    async extractWithLLM(text) {
+        return [];
+    }
+}
+exports.EntityExtractor = EntityExtractor;

package/gateway/dist/core/graph/graph-searcher.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphSearcher = void 0;
+class GraphSearcher {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    search(queryNodes, maxDepth = 2) {
+        const visited = new Set();
+        const result = [];
+        const queue = [];
+        for (const [id, node] of this.graph.nodes) {
+            if (queryNodes.some(q => node.label.toLowerCase().includes(q.toLowerCase()))) {
+                visited.add(id);
+                result.push(node);
+                queue.push({ nodeId: id, depth: 0 });
+            }
+        }
+        while (queue.length > 0) {
+            const { nodeId, depth } = queue.shift();
+            if (depth >= maxDepth)
+                continue;
+            for (const edge of this.graph.edges.values()) {
+                let neighborId = null;
+                if (edge.source === nodeId) {
+                    neighborId = edge.target;
+                }
+                else if (edge.target === nodeId) {
+                    neighborId = edge.source;
+                }
+                if (neighborId && !visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    const neighbor = this.graph.nodes.get(neighborId);
+                    if (neighbor) {
+                        result.push(neighbor);
+                        queue.push({ nodeId: neighborId, depth: depth + 1 });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    calculateImportance(nodeId) {
+        let totalWeight = 0;
+        let count = 0;
+        for (const edge of this.graph.edges.values()) {
+            if (edge.target === nodeId) {
+                totalWeight += edge.weight;
+                count++;
+            }
+        }
+        return totalWeight / Math.max(1, count);
+    }
+    findPath(from, toOrLabel, toLabel) {
+        const targetLabel = toLabel || toOrLabel;
+        const visited = new Set();
+        const queue = [];
+        const startNode = this.graph.nodes.get(from);
+        if (!startNode)
+            return [];
+        const isTarget = (node) => {
+            if (toLabel !== undefined) {
+                return node.label.toLowerCase().includes(targetLabel.toLowerCase());
+            }
+            return node.id === targetLabel;
+        };
+        if (isTarget(startNode))
+            return [startNode.id];
+        visited.add(from);
+        queue.push({ nodeId: from, path: [from] });
+        while (queue.length > 0) {
+            const { nodeId, path } = queue.shift();
+            for (const edge of this.graph.edges.values()) {
+                let neighborId = null;
+                if (edge.source === nodeId) {
+                    neighborId = edge.target;
+                }
+                else if (edge.target === nodeId) {
+                    neighborId = edge.source;
+                }
+                if (neighborId && !visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    const neighbor = this.graph.nodes.get(neighborId);
+                    if (neighbor) {
+                        const newPath = [...path, neighborId];
+                        if (isTarget(neighbor)) {
+                            return newPath;
+                        }
+                        queue.push({ nodeId: neighborId, path: newPath });
+                    }
+                }
+            }
+        }
+        return [];
+    }
+    findRelated(nodeId, relation, maxResults = 10) {
+        const connected = [];
+        for (const edge of this.graph.edges.values()) {
+            if (relation && edge.relation !== relation)
+                continue;
+            let neighborId = null;
+            if (edge.source === nodeId) {
+                neighborId = edge.target;
+            }
+            else if (edge.target === nodeId) {
+                neighborId = edge.source;
+            }
+            if (neighborId) {
+                const node = this.graph.nodes.get(neighborId);
+                if (node) {
+                    connected.push({ node, weight: edge.weight });
+                }
+            }
+        }
+        connected.sort((a, b) => b.weight - a.weight);
+        return connected.slice(0, maxResults).map(c => c.node);
+    }
+}
+exports.GraphSearcher = GraphSearcher;

package/gateway/dist/core/graph/knowledge-graph-manager.js

@@ -0,0 +1,138 @@
+"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.KnowledgeGraphManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const entity_extractor_1 = require("./entity-extractor");
+const relation_inferencer_1 = require("./relation-inferencer");
+class KnowledgeGraphManager {
+    graph;
+    storagePath;
+    extractor;
+    inferencer;
+    constructor(storagePath) {
+        this.storagePath = storagePath || './.mafw/data/knowledge-graph.json';
+        this.graph = { nodes: new Map(), edges: new Map() };
+        this.extractor = new entity_extractor_1.EntityExtractor();
+        this.inferencer = new relation_inferencer_1.RelationInferencer();
+    }
+    async load() {
+        if (!fs.existsSync(this.storagePath)) {
+            this.graph = { nodes: new Map(), edges: new Map() };
+            return;
+        }
+        const raw = fs.readFileSync(this.storagePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        this.graph = {
+            nodes: new Map(parsed.nodes.map(n => [n.key, n.value])),
+            edges: new Map(parsed.edges.map(e => [e.key, e.value])),
+        };
+    }
+    async save() {
+        const dir = path.dirname(this.storagePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const serialized = {
+            nodes: Array.from(this.graph.nodes.entries()).map(([key, value]) => ({ key, value })),
+            edges: Array.from(this.graph.edges.entries()).map(([key, value]) => ({ key, value })),
+        };
+        const tmp = this.storagePath + '.tmp';
+        fs.writeFileSync(tmp, JSON.stringify(serialized, null, 2), 'utf-8');
+        fs.renameSync(tmp, this.storagePath);
+    }
+    addNode(node) {
+        this.graph.nodes.set(node.id, node);
+    }
+    addEdge(edge) {
+        this.graph.edges.set(edge.id, edge);
+    }
+    removeNode(nodeId) {
+        this.graph.nodes.delete(nodeId);
+        for (const [edgeId, edge] of this.graph.edges) {
+            if (edge.source === nodeId || edge.target === nodeId) {
+                this.graph.edges.delete(edgeId);
+            }
+        }
+    }
+    removeEdge(edgeId) {
+        this.graph.edges.delete(edgeId);
+    }
+    getNode(nodeId) {
+        return this.graph.nodes.get(nodeId);
+    }
+    search(query, maxResults = 10) {
+        const lower = query.toLowerCase();
+        const results = [];
+        for (const node of this.graph.nodes.values()) {
+            if (node.label.toLowerCase().includes(lower)) {
+                results.push(node);
+                if (results.length >= maxResults)
+                    break;
+            }
+        }
+        return results;
+    }
+    getGraph() {
+        return {
+            nodes: Array.from(this.graph.nodes.values()),
+            edges: Array.from(this.graph.edges.values()),
+        };
+    }
+    async processObservation(text, loopNum) {
+        const entities = this.extractor.extract(text);
+        const edges = this.inferencer.inferRelations(entities, text);
+        for (const entity of entities) {
+            const nodeId = `node-${entity}`;
+            if (!this.graph.nodes.has(nodeId)) {
+                this.graph.nodes.set(nodeId, {
+                    id: nodeId,
+                    type: 'concept',
+                    label: entity,
+                    energy: 0.5,
+                    sourceLoops: [loopNum],
+                    properties: {},
+                    createdAt: new Date().toISOString(),
+                });
+            }
+        }
+        for (const edge of edges) {
+            edge.sourceLoops.push(loopNum);
+            this.graph.edges.set(edge.id, edge);
+        }
+    }
+}
+exports.KnowledgeGraphManager = KnowledgeGraphManager;

package/gateway/dist/core/graph/relation-inferencer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationInferencer = void 0;
+class RelationInferencer {
+    inferRelations(entities, context) {
+        const edges = [];
+        const sentences = context.split(/[.!?]+/).map(s => s.trim()).filter(Boolean);
+        const entitiesInSentence = (sentence) => {
+            return entities.filter(e => sentence.toLowerCase().includes(e.toLowerCase()));
+        };
+        for (const sentence of sentences) {
+            const present = entitiesInSentence(sentence);
+            if (present.length >= 2) {
+                for (let i = 0; i < present.length; i++) {
+                    for (let j = i + 1; j < present.length; j++) {
+                        edges.push({
+                            id: this.generateId(),
+                            source: present[i],
+                            target: present[j],
+                            relation: 'co_occurs',
+                            weight: 0.5,
+                            sourceLoops: [],
+                            createdAt: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+            if (present.length >= 2) {
+                const lower = sentence.toLowerCase();
+                let relation = null;
+                let weight = 0;
+                if (/\b(depends on|requires|uses)\b/i.test(lower)) {
+                    relation = 'depends_on';
+                    weight = 0.7;
+                }
+                else if (/\b(error|fix|bug|issue)\b/i.test(lower)) {
+                    relation = 'causes';
+                    weight = 0.8;
+                }
+                else if (/\b(part of|belongs to)\b/i.test(lower)) {
+                    relation = 'part_of';
+                    weight = 0.6;
+                }
+                if (relation) {
+                    for (let i = 0; i < present.length; i++) {
+                        for (let j = i + 1; j < present.length; j++) {
+                            edges.push({
+                                id: this.generateId(),
+                                source: present[i],
+                                target: present[j],
+                                relation,
+                                weight,
+                                sourceLoops: [],
+                                createdAt: new Date().toISOString(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return edges;
+    }
+    generateId() {
+        return `edge-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    }
+}
+exports.RelationInferencer = RelationInferencer;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/gateway/dist/core/hooks/handoff.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handoffHook = handoffHook;
+async function handoffHook(ctx) {
+    if (ctx.context) {
+    }
+}

package/gateway/dist/core/hooks/hook-manager.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = void 0;
+const logger_1 = require("../utils/logger");
+class HookManager {
+    hooks;
+    config;
+    constructor(config) {
+        this.hooks = new Map();
+        this.config = {
+            failBehavior: config?.failBehavior || 'continue',
+            timeout: config?.timeout ?? 30000
+        };
+    }
+    register(hook) {
+        const event = hook.event;
+        if (!this.hooks.has(event)) {
+            this.hooks.set(event, []);
+        }
+        this.hooks.get(event).push(hook);
+        this.hooks.get(event).sort((a, b) => a.priority - b.priority);
+    }
+    registerMany(hooks) {
+        for (const hook of hooks) {
+            this.register(hook);
+        }
+    }
+    unregister(name) {
+        for (const [event, registrations] of this.hooks) {
+            const index = registrations.findIndex(h => h.name === name);
+            if (index !== -1) {
+                registrations.splice(index, 1);
+                if (registrations.length === 0) {
+                    this.hooks.delete(event);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    async execute(event, context) {
+        const registrations = this.hooks.get(event);
+        if (!registrations || registrations.length === 0) {
+            return;
+        }
+        const fullContext = {
+            event,
+            data: context.data,
+            config: this.config,
+            ...context
+        };
+        for (const hook of registrations) {
+            const timeout = hook.timeout ?? this.config.timeout;
+            try {
+                await Promise.race([
+                    hook.handler(fullContext),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Hook "${hook.name}" timed out after ${timeout}ms`)), timeout))
+                ]);
+            }
+            catch (err) {
+                if (this.config.failBehavior === 'continue') {
+                    logger_1.log.error(`[HookManager] Hook "${hook.name}" failed: ${err.message}`);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    getHooks(event) {
+        if (event) {
+            return [...(this.hooks.get(event) || [])];
+        }
+        const result = [];
+        for (const registrations of this.hooks.values()) {
+            result.push(...registrations);
+        }
+        return result;
+    }
+    clear() {
+        this.hooks.clear();
+    }
+    size() {
+        let count = 0;
+        for (const registrations of this.hooks.values()) {
+            count += registrations.length;
+        }
+        return count;
+    }
+}
+exports.HookManager = HookManager;

package/gateway/dist/core/hooks/llm-after.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmAfterHook = llmAfterHook;
+async function llmAfterHook(ctx) {
+    if (!ctx.text)
+        return;
+}

package/gateway/dist/core/hooks/observation-capture.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureObservation = captureObservation;
+async function captureObservation(ctx) {
+    const outputLength = ctx.output?.length || 0;
+    const summary = outputLength > 200
+        ? ctx.output.substring(0, 100) + '...' + ctx.output.substring(outputLength - 100)
+        : ctx.output;
+    return {
+        observation: {
+            type: 'observation',
+            tool: ctx.toolName,
+            args: ctx.args || '',
+            output: ctx.output || '',
+            timestamp: new Date().toISOString(),
+            summary
+        }
+    };
+}

package/gateway/dist/core/hooks/session-compacting.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionCompactingHook = sessionCompactingHook;
+async function sessionCompactingHook(ctx) {
+}