@jack200714/mafw 4.5.1

package/gateway/dist/chat/chat-sessions.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSessionManager = void 0;
+const SSE_HEADERS = {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+};
+class ChatSessionManager {
+    sessions = new Map();
+    /** Register an SSE connection to listen for a specific session's events */
+    register(sessionID, res) {
+        res.writeHead(200, SSE_HEADERS);
+        res.write(`data: ${JSON.stringify({ type: 'connected', sessionID })}\n\n`);
+        if (!this.sessions.has(sessionID)) {
+            this.sessions.set(sessionID, new Set());
+        }
+        this.sessions.get(sessionID).add(res);
+        const self = this;
+        res.on('close', () => {
+            const set = self.sessions.get(sessionID);
+            if (set) {
+                set.delete(res);
+                if (set.size === 0) {
+                    self.sessions.delete(sessionID);
+                }
+            }
+        });
+    }
+    /** Push a text delta to all SSE connections for a session */
+    pushDelta(sessionID, text) {
+        const set = this.sessions.get(sessionID);
+        if (!set)
+            return;
+        const data = `data: ${JSON.stringify({ type: 'message_delta', sessionID, content: text })}\n\n`;
+        for (const res of set) {
+            try {
+                res.write(data);
+            }
+            catch {
+                this.removeResponse(sessionID, res);
+            }
+        }
+    }
+    /** Signal completion to all SSE connections for a session */
+    pushComplete(sessionID) {
+        const set = this.sessions.get(sessionID);
+        if (!set)
+            return;
+        const data = `data: ${JSON.stringify({ type: 'message_complete', sessionID })}\n\n`;
+        for (const res of set) {
+            try {
+                res.write(data);
+                res.end();
+            }
+            catch { /* client already gone */ }
+        }
+        this.sessions.delete(sessionID);
+    }
+    /** Signal error to all SSE connections for a session */
+    pushError(sessionID, error) {
+        const set = this.sessions.get(sessionID);
+        if (!set)
+            return;
+        const data = `data: ${JSON.stringify({ type: 'message_error', sessionID, error })}\n\n`;
+        for (const res of set) {
+            try {
+                res.write(data);
+                res.end();
+            }
+            catch { /* client already gone */ }
+        }
+        this.sessions.delete(sessionID);
+    }
+    /** Check if any SSE connections are listening for a session */
+    hasListeners(sessionID) {
+        const set = this.sessions.get(sessionID);
+        return !!set && set.size > 0;
+    }
+    /** Get all tracked session IDs */
+    getTrackedSessions() {
+        return Array.from(this.sessions.keys());
+    }
+    removeResponse(sessionID, res) {
+        const set = this.sessions.get(sessionID);
+        if (set) {
+            set.delete(res);
+            if (set.size === 0) {
+                this.sessions.delete(sessionID);
+            }
+        }
+    }
+}
+exports.ChatSessionManager = ChatSessionManager;

package/gateway/dist/chat/graph-runner.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRunner = void 0;
+const logger_1 = require("../core/utils/logger");
+const config_1 = require("../config");
+const langgraph_1 = require("../core/langgraph");
+const loop_monitor_1 = require("../loop-monitor");
+class GraphRunner {
+    projectDir;
+    mafwDir;
+    loopMonitor = null;
+    constructor(projectDir, mafwDir) {
+        this.projectDir = projectDir;
+        this.mafwDir = mafwDir;
+        // Initialize loop monitor for stuck loop detection
+        const statusPath = require('path').join(mafwDir, 'status.md');
+        this.loopMonitor = new loop_monitor_1.LoopMonitor(statusPath);
+    }
+    /**
+     * Check if the loop is stuck (no updates for stuckLoopTimeout ms).
+     * Returns true if stuck and should be intervened.
+     */
+    isLoopStuck() {
+        if (!this.loopMonitor)
+            return false;
+        try {
+            return this.loopMonitor.isStuck(config_1.config.timeouts.stuckLoopTimeout);
+        }
+        catch {
+            return false;
+        }
+    }
+    async run(goalId, extraContext, onState, signal) {
+        const timeoutSignal = AbortSignal.timeout(config_1.config.timeouts.graphRunTimeout);
+        const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+        const graph = (0, langgraph_1.buildExecutionGraph)(this.buildNodeOptions(this.mafwDir));
+        graph.checkpointer = new langgraph_1.FileCheckpointer(this.mafwDir);
+        const initialState = {
+            goalId: goalId,
+            projectDir: this.projectDir,
+            mafwDir: this.mafwDir,
+            round: 1,
+            maxRounds: config_1.config.loop.maxRounds,
+            ...extraContext,
+        };
+        const stream = await graph.stream(initialState, {
+            configurable: { thread_id: goalId },
+            signal: combinedSignal,
+        });
+        for await (const event of stream) {
+            // Check for stuck loop before processing event
+            if (this.isLoopStuck()) {
+                logger_1.log.warn(`[GraphRunner] Loop ${goalId} appears stuck (no updates for ${config_1.config.timeouts.stuckLoopTimeout}ms)`);
+                // Continue processing but log warning - actual intervention is done by caller
+            }
+            const nodeName = event.name || event.metadata?.name;
+            const nodeOutput = event.data?.output || event;
+            if (nodeName && nodeOutput?.phase) {
+                onState({ activeNodeId: nodeName.toUpperCase(), phase: nodeOutput.phase });
+            }
+        }
+        return { status: 'completed' };
+    }
+    buildNodeOptions(mafwDir) {
+        return {
+            plan: async (s) => ({ wavePlanPath: null, round: s.round }),
+            askUser: async (s) => ({ pendingQuestion: null }),
+            execute: async (s) => ({ receiptPath: null }),
+            review: async (s) => ({ reviewVerdict: 'PASS', reviewReportPath: null, reviewFeedback: '' }),
+            archiveSuccess: async (s) => { logger_1.log.info(`[ChatGraph] ${s.goalId} PASSED`); return {}; },
+            archiveFail: async (s) => { logger_1.log.error(`[ChatGraph] ${s.goalId} FAILED: ${s.lastError}`); return {}; },
+            archiveMaxRetries: async (s) => { logger_1.log.error(`[ChatGraph] ${s.goalId} max retries`); return {}; },
+        };
+    }
+}
+exports.GraphRunner = GraphRunner;

package/gateway/dist/chat/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRunner = exports.IntentClassifier = void 0;
+var intent_classifier_1 = require("./intent-classifier");
+Object.defineProperty(exports, "IntentClassifier", { enumerable: true, get: function () { return intent_classifier_1.IntentClassifier; } });
+var graph_runner_1 = require("./graph-runner");
+Object.defineProperty(exports, "GraphRunner", { enumerable: true, get: function () { return graph_runner_1.GraphRunner; } });

package/gateway/dist/chat/intent-classifier.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentClassifier = void 0;
+const config_1 = require("../config");
+class IntentClassifier {
+    executeKw;
+    searchKw;
+    constructor(executeKw, searchKw) {
+        this.executeKw = executeKw ?? config_1.config.chat.executeGraphKeywords;
+        this.searchKw = searchKw ?? config_1.config.chat.searchMemoryKeywords;
+    }
+    classify(message) {
+        const lower = message.toLowerCase();
+        if (this.executeKw.some(kw => lower.includes(kw))) {
+            return { action: 'EXECUTE_GRAPH', entities: {} };
+        }
+        if (this.searchKw.some(kw => lower.includes(kw))) {
+            return { action: 'SEARCH_MEMORY', entities: {} };
+        }
+        return { action: 'RAG_ONLY', entities: {} };
+    }
+}
+exports.IntentClassifier = IntentClassifier;

package/gateway/dist/config.js

@@ -0,0 +1,416 @@
+"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.config = exports.Config = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const yaml = __importStar(require("js-yaml"));
+function defaults(projectDir) {
+    return {
+        server: {
+            apiPort: 3000,
+            serveUrl: 'http://127.0.0.1:4096',
+            servePort: 4096,
+            serveHost: '127.0.0.1',
+            mcpUrl: 'http://localhost:3001/sse',
+            dashboardPort: 3111,
+            cors: {
+                origin: '*',
+                methods: 'GET, POST, OPTIONS',
+                headers: 'Content-Type',
+            },
+            apiToken: '',
+        },
+        paths: {
+            projectDir,
+            mafwDir: '.mafw',
+            globalConfig: path.join(os.homedir(), '.config', 'mafw', 'config.yaml'),
+            registryFile: path.join(projectDir, 'scheduler', 'registered-projects.json'),
+            dashboardPublic: path.join(__dirname, '..', 'dist', 'dashboard', 'public'),
+            mcpServerScript: './core/mcp-server.js',
+        },
+        timeouts: {
+            serveReadyWait: 60000,
+            serveHealthCheckInterval: 1000,
+            serveRestartDelay: 5000,
+            serveReadyMaxRetries: 60,
+            backupPollInterval: 30000,
+            graphRunTimeout: 120000,
+            heartbeatTimeout: 300000,
+            sessionRequestTimeout: 10000,
+            sessionHealthCheckTimeout: 5000,
+            serverWaitTimeout: 30000,
+            serverWaitRetryInterval: 1000,
+            triageDeadline: 86400000,
+            stuckLoopTimeout: 300000,
+            llmApiTimeout: 15000,
+            streamingCharDelay: 20,
+        },
+        loop: {
+            maxRounds: 3,
+            maxLoops: 5,
+            initialRound: 1,
+            degradeOnLoopFactor: 0.6,
+        },
+        search: {
+            defaultTopK: 20,
+            maxMemoryResults: 50,
+            axiomsTopK: 10,
+            defaultRetriever: 'bm25',
+            reranker: 'off',
+            recallK: 50,
+            cutoffRatio: 0,
+            rerankWeights: {
+                bm25: 0.6,
+                recency: 0.2,
+                energy: 0.1,
+                salience: 0.1,
+            },
+            graph: {
+                enabled: true,
+                maxHops: 1,
+                maxNeighbors: 3,
+                damping: 0.6,
+                candidateCap: 50,
+                rerankGraphWeight: 0.15,
+            },
+            maxExpandRounds: 2,
+            /** Sparse weight in weighted RRF (hybrid retrieval). >0.5 favors BM25 ordering. */
+            fusionSparseWeight: 0.65,
+        },
+        memory: {
+            defaultEnergy: 0.8,
+            defaultMemoryType: 'semantic',
+            maxCueAnchors: 8,
+            abstractionMaxLength: 200,
+            defaultPrimaryAbstractionLength: 80,
+            defaultSalience: 1.0,
+            embedding: {
+                provider: 'off',
+                model: 'onnx-community/Qwen3-Embedding-0.6B-ONNX',
+                dimensions: 1024,
+                baseUrl: '',
+                minCosine: 0.8,
+                consolidation: true,
+                threads: 2,
+                engine: 'onnx',
+                llamacpp: {
+                    port: 0,
+                    threads: 2,
+                    contextSize: 2048,
+                    gpu: 'cpu',
+                    modelFile: '',
+                    binaryVersion: 'b10752',
+                },
+            },
+        },
+        llm: {
+            defaultProvider: 'anthropic',
+            defaultModel: 'claude-3-haiku-20240307',
+            apiKeyEnv: 'MAFW_LLM_API_KEY',
+            anthropicVersion: '2023-06-01',
+            maxTokens: 500,
+        },
+        logging: {
+            logDir: path.join(os.homedir(), '.mafw', 'logs'),
+            maxFileSize: 5242880,
+            logLevel: 'debug',
+        },
+        mcpserver: {
+            name: 'mafw-mcp-server',
+            version: '4.1.0',
+            transportPath: '/mcp',
+        },
+        metrics: {
+            maxInMemory: 1000,
+            pruneRetainCount: 500,
+            recentSnapshotSize: 50,
+            maxEventEmitterListeners: 100,
+        },
+        chat: {
+            executeGraphKeywords: ['开始', '规划', '执行', 'run'],
+            searchMemoryKeywords: ['搜索', '查找', '记忆', 'search'],
+        },
+        alignment: {
+            userWeightsFile: 'user-weights.json',
+        },
+        manager: {
+            wakeCooldownMs: parseInt(process.env.MAFW_MANAGER_WAKE_COOLDOWN || '') || 60000,
+            reportIntervalMin: parseInt(process.env.MAFW_MANAGER_REPORT_INTERVAL || '') || 5,
+        },
+        recall: {
+            stepInjectThreshold: 0.7,
+            stepInjectMaxMemories: 2,
+            stepInjectIntervalMs: 15 * 60 * 1000,
+            stepInjectQueueCap: 3,
+            stepInjectTtlMs: 24 * 60 * 60 * 1000,
+            turnStaleMs: 30 * 60 * 1000,
+            obsCapturePath: 'memory/gateway.db',
+            sessionWorkerTtlMs: 24 * 60 * 60 * 1000,
+            reflectThresholdEpisodic: 3,
+            maxEpisodicPerReflect: 100,
+            workerModel: { providerID: 'alibaba-cn', modelID: 'qwen3.7-max' },
+            workerCompactIdleMs: 8 * 60 * 60 * 1000,
+        },
+        usage: {
+            pollIntervalMs: 60000,
+            limits: {
+                'opencode-go': { '5h': 12, '7d': 30, month: 60 },
+                zen: { balance: 100 },
+            },
+            budgets: {},
+            cookies: {},
+            pluginConfig: {},
+        },
+        trajectory: {
+            retentionDays: 365,
+        },
+        media: {
+            provider: 'xiaomi',
+            model: 'mimo-v2.5',
+            // Nested stubs so MAFW_MEDIA_IMAGE_MODEL / MAFW_MEDIA_VIDEO_MODEL /
+            // MAFW_MEDIA_AUDIO_MODEL / MAFW_MEDIA_LANG env overrides are honored by
+            // applyEnvOverrides (it only walks keys present in the defaults).
+            // Empty model falls back to the top-level `model` at resolve time.
+            image: { model: '' },
+            video: { model: '' },
+            audio: { model: '' },
+            lang: '',
+            tts: {
+                baseUrl: 'https://api.xiaomimimo.com/v1',
+                model: 'mimo-v2.5-tts',
+                defaultVoice: '茉莉',
+                voices: ['冰糖', '茉莉', '苏打', '白桦', 'Mia', 'Chloe', 'Milo', 'Dean'],
+            },
+        },
+        runtime: {
+            // 空串默认值让 MAFW_RUNTIME_PLUGIN 环境变量覆盖生效
+            // （applyEnvOverrides 只遍历 defaults 里存在的 key）。
+            plugin: '',
+        },
+        env: {
+            mafwOpencodePath: 'MAFW_OPENCODE_PATH',
+            enableLegacyMcp: 'ENABLE_LEGACY_MCP',
+            mafwProjectDir: 'MAFW_PROJECT_DIR',
+        },
+    };
+}
+class Config {
+    data;
+    projectDirValue;
+    dataDirValue;
+    get raw() { return this.data; }
+    /**
+     * MAFW data root — pinned to the user's home .mafw directory so the memory
+     * store (T1 db, harmonic index, reflect cursor), manager sessions and the
+     * registry never depend on the process working directory, MAFW_PROJECT_DIR
+     * or the gateway package's install location. The `paths.mafwDir` config key
+     * no longer redirects this. Tests may inject an alternative dataDir.
+     */
+    static gatewayMafwDir() {
+        return path.join(os.homedir(), '.mafw');
+    }
+    constructor(projectDir, dataDir) {
+        // Resolve to an absolute path so relative stores (T1 db, cursors, memory
+        // files) never depend on the process working directory at runtime.
+        this.projectDirValue = path.resolve(projectDir || process.env[defaults('.').env.mafwProjectDir] || '.');
+        this.dataDirValue = dataDir ? path.resolve(dataDir) : Config.gatewayMafwDir();
+        this.data = this.buildData(this.projectDirValue);
+    }
+    buildData(pd) {
+        const data = defaults(pd);
+        const globalFile = data.paths.globalConfig;
+        this.deepMerge(data, this.loadYaml(globalFile));
+        // Project-level config now lives in the fixed data directory (migrated
+        // with the memory store) rather than the project-relative .mafw.
+        const projectFile = path.join(this.dataDirValue, 'config.yaml');
+        this.deepMerge(data, this.loadYaml(projectFile));
+        this.applyEnvOverrides(data);
+        return data;
+    }
+    /**
+     * Hot-reload config files. Rebuilds from defaults so deleted keys fall back
+     * to default values; immutable sections (server/paths) keep their old values
+     * and are reported as restart-required so runtime state stays consistent
+     * with what is actually listening/serving.
+     */
+    reload() {
+        const before = JSON.stringify(this.data);
+        const next = this.buildData(this.projectDirValue);
+        const restartRequired = [];
+        if (JSON.stringify(next.server) !== JSON.stringify(this.data.server)) {
+            // Split apiToken from restart-required: token changes take effect on
+            // next request without a gateway restart.
+            const { apiToken: _nextToken, ...nextServerRest } = next.server;
+            const { apiToken: _curToken, ...curServerRest } = this.data.server;
+            if (JSON.stringify(nextServerRest) !== JSON.stringify(curServerRest)) {
+                next.server = this.data.server;
+                restartRequired.push('server');
+            }
+            else {
+                // Only apiToken changed — apply it without restart
+                this.data.server.apiToken = next.server.apiToken;
+            }
+        }
+        if (JSON.stringify(next.paths) !== JSON.stringify(this.data.paths)) {
+            next.paths = this.data.paths;
+            restartRequired.push('paths');
+        }
+        const after = JSON.stringify(next);
+        const changed = [];
+        if (before !== after) {
+            for (const key of Object.keys(this.data)) {
+                if (JSON.stringify(this.data[key]) !== JSON.stringify(next[key]))
+                    changed.push(key);
+            }
+        }
+        this.data = next;
+        return { changed, restartRequired };
+    }
+    get server() { return this.data.server; }
+    get paths() { return this.data.paths; }
+    get timeouts() { return this.data.timeouts; }
+    get loop() { return this.data.loop; }
+    get search() { return this.data.search; }
+    get memory() { return this.data.memory; }
+    get llm() { return this.data.llm; }
+    get mcpserver() { return this.data.mcpserver; }
+    get metrics() { return this.data.metrics; }
+    get chat() { return this.data.chat; }
+    get alignment() { return this.data.alignment; }
+    get env() { return this.data.env; }
+    get manager() { return this.data.manager; }
+    get recall() { return this.data.recall; }
+    get usage() { return this.data.usage; }
+    get trajectory() { return this.data.trajectory; }
+    get runtime() { return this.data.runtime; }
+    /**
+     * Persist partial config overrides to the project-level config.yaml.
+     * Merges overrides into the current in-memory config and writes the
+     * entire config to disk so the override survives restarts.
+     *
+     * @returns An object with `changed`: list of top-level section keys that
+     *          were actually modified (compared to the previous in-memory state).
+     */
+    persistOverrides(overrides) {
+        const changed = [];
+        for (const key of Object.keys(overrides)) {
+            const prev = JSON.stringify(this.data[key]);
+            const next = JSON.stringify(overrides[key]);
+            if (prev !== next) {
+                changed.push(key);
+            }
+        }
+        // Deep-merge overrides into current config
+        this.deepMerge(this.data, overrides);
+        // Write to the data-dir config.yaml (project-level overrides)
+        const filePath = path.join(this.dataDirValue, 'config.yaml');
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, yaml.dump(this.data, { indent: 2 }), 'utf-8');
+        return { changed };
+    }
+    /**
+     * MAFW data root — pinned to the gateway package's own .mafw directory so
+     * the memory store (T1 db, harmonic index, reflect cursor) and pipeline
+     * runtime files never depend on the process working directory or
+     * MAFW_PROJECT_DIR. The `paths.mafwDir` config key no longer redirects this.
+     */
+    resolvePath(...segments) {
+        return path.join(this.dataDirValue, ...segments);
+    }
+    loadYaml(filePath) {
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            return yaml.load(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    deepMerge(target, source) {
+        if (!source || typeof source !== 'object')
+            return;
+        for (const key of Object.keys(source)) {
+            const sv = source[key];
+            if (sv !== null && typeof sv === 'object' && !Array.isArray(sv)) {
+                if (!target[key] || typeof target[key] !== 'object')
+                    target[key] = {};
+                this.deepMerge(target[key], sv);
+            }
+            else if (sv !== undefined) {
+                target[key] = sv;
+            }
+        }
+    }
+    envKey(...segments) {
+        return 'MAFW_' + segments.map(s => s.replace(/([A-Z])/g, '_$1').replace(/^_/, '').toUpperCase()).join('_');
+    }
+    applyEnvOverrides(obj, prefix = '') {
+        for (const key of Object.keys(obj)) {
+            const value = obj[key];
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                this.applyEnvOverrides(value, prefix ? prefix + '.' + key : key);
+            }
+            else {
+                const segments = prefix ? prefix.split('.') : [];
+                segments.push(key);
+                const envKey = this.envKey(...segments);
+                const envVal = process.env[envKey];
+                if (envVal === undefined)
+                    continue;
+                if (typeof value === 'number') {
+                    obj[key] = Number(envVal);
+                }
+                else if (typeof value === 'boolean') {
+                    obj[key] = envVal === 'true' || envVal === '1';
+                }
+                else if (Array.isArray(value)) {
+                    obj[key] = envVal.split(',').map(s => s.trim());
+                }
+                else {
+                    obj[key] = envVal;
+                }
+            }
+        }
+    }
+}
+exports.Config = Config;
+exports.config = new Config();