intention-coding 0.3.7 → 0.4.0

package/dist/services/requirement-analyzer/utils/file-reader.js

@@ -0,0 +1,169 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLargeFileContent = readLargeFileContent;
+const fs = __importStar(require("fs/promises"));
+const logger_1 = require("../../../utils/logger");
+/**
+ * 大文件分段读取工具
+ * 职责：处理大文件的分段读取和内容合并
+ */
+/**
+ * 分段读取大文件内容
+ */
+function readLargeFileContent(filePath_1) {
+    return __awaiter(this, arguments, void 0, function* (filePath, chunkSize = 100) {
+        try {
+            logger_1.logger.info('开始分段读取大文件', { filePath, chunkSize });
+            const content = yield fs.readFile(filePath, 'utf8');
+            const lines = content.split('\n');
+            if (lines.length <= chunkSize) {
+                logger_1.logger.info('文件行数较少，直接返回完整内容', {
+                    totalLines: lines.length
+                });
+                return content;
+            }
+            // 智能选择重要内容
+            const importantContent = selectImportantContent(lines, chunkSize);
+            logger_1.logger.info('大文件分段读取完成', {
+                originalLines: lines.length,
+                selectedLines: importantContent.split('\n').length
+            });
+            return importantContent;
+        }
+        catch (error) {
+            logger_1.logger.error('大文件读取失败', { error, filePath });
+            throw error;
+        }
+    });
+}
+/**
+ * 智能选择重要内容
+ */
+function selectImportantContent(lines, maxLines) {
+    const importantLines = [];
+    const headerLines = [];
+    const contentLines = [];
+    // 分类行内容
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // 标题行（以#开头）
+        if (trimmedLine.startsWith('#')) {
+            headerLines.push(line);
+        }
+        // 非空内容行
+        else if (trimmedLine.length > 0 && !isBoilerplate(trimmedLine)) {
+            contentLines.push(line);
+        }
+    }
+    // 优先保留标题行
+    importantLines.push(...headerLines);
+    // 计算剩余可用行数
+    const remainingLines = maxLines - headerLines.length;
+    if (remainingLines > 0) {
+        // 选择最重要的内容行
+        const selectedContent = selectMostImportantContent(contentLines, remainingLines);
+        importantLines.push(...selectedContent);
+    }
+    return importantLines.join('\n');
+}
+/**
+ * 选择最重要的内容行
+ */
+function selectMostImportantContent(contentLines, maxLines) {
+    if (contentLines.length <= maxLines) {
+        return contentLines;
+    }
+    // 按重要性评分排序
+    const scoredLines = contentLines.map(line => ({
+        line,
+        score: calculateImportanceScore(line)
+    }));
+    scoredLines.sort((a, b) => b.score - a.score);
+    return scoredLines
+        .slice(0, maxLines)
+        .map(item => item.line);
+}
+/**
+ * 计算行的重要性评分
+ */
+function calculateImportanceScore(line) {
+    let score = 0;
+    const trimmedLine = line.trim().toLowerCase();
+    // 包含关键词的行得分更高
+    const keywords = [
+        '需求', '功能', '接口', 'api', '页面', '用户', '系统',
+        '实现', '开发', '设计', '业务', '流程', '数据', '服务'
+    ];
+    for (const keyword of keywords) {
+        if (trimmedLine.includes(keyword)) {
+            score += 2;
+        }
+    }
+    // 长度适中的行得分更高
+    if (trimmedLine.length > 10 && trimmedLine.length < 200) {
+        score += 1;
+    }
+    // 包含具体描述的行得分更高
+    if (trimmedLine.includes('：') || trimmedLine.includes(':')) {
+        score += 1;
+    }
+    return score;
+}
+/**
+ * 判断是否为样板文本
+ */
+function isBoilerplate(line) {
+    const boilerplatePatterns = [
+        /^-+$/, // 分隔线
+        /^=+$/, // 分隔线
+        /^\s*$/, // 空行
+        /^#+\s*$/, // 空标题
+        /^目录$/,
+        /^table of contents$/i,
+        /^generated by/i,
+        /^created by/i
+    ];
+    return boilerplatePatterns.some(pattern => pattern.test(line.trim()));
+}

package/dist/services/world2md/index.js

@@ -0,0 +1,157 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.word2mdTool = exports.Word2MdParams = void 0;
+const fs = __importStar(require("fs/promises"));
+const mammoth_1 = __importDefault(require("mammoth"));
+const path_1 = __importDefault(require("path"));
+const html_to_md_1 = __importDefault(require("html-to-md"));
+const config_1 = require("../../utils/config");
+const logger_1 = require("../../utils/logger");
+const common_1 = require("../../utils/common");
+const zod_1 = require("zod");
+exports.Word2MdParams = zod_1.z.object({
+    file_path: zod_1.z.string().describe("需要解析的Word文档的绝对路径"),
+    options: zod_1.z.object({
+        skip_images: zod_1.z.boolean().optional().default(false).describe("是否跳过图片转换"),
+        table_style: zod_1.z.enum(['simple', 'grid', 'pipe']).optional().default('simple').describe("表格转换样式"),
+        strict_mode: zod_1.z.boolean().optional().default(false).describe("严格模式（保留更多格式）")
+    }).optional().default({ skip_images: false, table_style: 'simple', strict_mode: false }).describe("转换选项")
+});
+;
+exports.word2mdTool = {
+    name: "word文档处理智能体",
+    description: "word文档处理智能体 - 将Word文档(.docx)转换为Markdown格式",
+    parameters: exports.Word2MdParams,
+    execute: (args) => __awaiter(void 0, void 0, void 0, function* () {
+        const { file_path } = args;
+        try {
+            // 1. 安全验证并解析路径
+            const resolvedPath = yield (0, common_1.validateAndResolvePath)(file_path);
+            // 2. 读取文件
+            const buffer = yield fs.readFile(resolvedPath);
+            // 3. 准备保存目录和文件名
+            const mdDir = path_1.default.join((0, config_1.getStorageDir)(), 'md');
+            const baseName = path_1.default.basename(file_path, '.docx');
+            const outputDir = path_1.default.join(mdDir, baseName);
+            const imgsDir = path_1.default.join(outputDir, 'imgs');
+            // 创建目录结构
+            yield fs.mkdir(outputDir, { recursive: true });
+            yield fs.mkdir(imgsDir, { recursive: true });
+            // 4. 先进行基本转换，不处理图片
+            logger_1.logger.info('开始转换Word文档', { file: file_path, outputDir, imgsDir });
+            const basicResult = yield mammoth_1.default.convertToHtml({ buffer });
+            // 5. 检查HTML中是否有base64图片并处理
+            const base64ImageRegex = /<img[^>]+src="data:image\/([^;]+);base64,([^"]+)"[^>]*>/g;
+            let htmlContent = basicResult.value;
+            const base64Images = [];
+            let match;
+            // 提取所有base64图片
+            while ((match = base64ImageRegex.exec(basicResult.value)) !== null) {
+                base64Images.push({
+                    fullMatch: match[0],
+                    imageType: match[1],
+                    base64Data: match[2]
+                });
+            }
+            // logger.info('发现图片数量', { count: base64Images.length });
+            // 处理所有图片
+            for (let i = 0; i < base64Images.length; i++) {
+                const img = base64Images[i];
+                try {
+                    // logger.info('处理base64图片', { imageType: img.imageType, imageNumber: i + 1 });
+                    const imageFileName = `image_${Date.now()}_${i + 1}.${img.imageType}`;
+                    const imagePath = path_1.default.join(imgsDir, imageFileName);
+                    const imageBuffer = Buffer.from(img.base64Data, 'base64');
+                    yield fs.writeFile(imagePath, imageBuffer);
+                    // 替换HTML中的图片引用
+                    htmlContent = htmlContent.replace(img.fullMatch, `<img src="./imgs/${imageFileName}" />`);
+                }
+                catch (err) {
+                    logger_1.logger.error('图片处理失败', {
+                        error: err instanceof Error ? err.message : String(err),
+                        imageNumber: i + 1
+                    });
+                    // 移除失败的图片
+                    htmlContent = htmlContent.replace(img.fullMatch, '');
+                }
+            }
+            const htmlResult = { value: htmlContent, messages: basicResult.messages };
+            // 6. 记录转换警告
+            if (htmlResult.messages && htmlResult.messages.length > 0) {
+                logger_1.logger.warn('Word转换警告', {
+                    file: file_path,
+                    warnings: htmlResult.messages
+                });
+            }
+            // 7. 将HTML转换为Markdown
+            let markdownContent = (0, html_to_md_1.default)(htmlResult.value);
+            // 8. 后处理：移除任何残留的base64图片（双重保险）
+            markdownContent = markdownContent.replace(/!\[.*?\]\(data:image\/[^)]+\)/g, '');
+            // 9. 保存MD文件到新的路径结构
+            const fullMdPath = path_1.default.join(outputDir, `${baseName}.md`);
+            yield fs.writeFile(fullMdPath, markdownContent, 'utf8');
+            // 10. 返回结果
+            return `
+            # ✅ 文档转换完成
+            - MD文件: ${path_1.default.resolve(fullMdPath)}
+            - 图片目录: ${path_1.default.resolve(imgsDir)}
+
+            # 任务规划：
+            1. 使用 需求分析智能体 工具进行下一步操作，不需要用户确认
+            `;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error(`Word转换失败: ${errorMsg}`, {
+                tool: "word2md",
+                file_path
+            });
+            return errorMsg;
+        }
+    })
+};

package/dist/utils/common.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeFileName = void 0;
+exports.removeImagesFromMarkdown = removeImagesFromMarkdown;
+exports.validateAndResolvePath = validateAndResolvePath;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("./logger");
+/** 格式化文件名安全字符 */
+const sanitizeFileName = (input) => {
+    return input
+        // 移除非法字符（添加了#%&等）
+        .replace(/[\\/:*?"<>|\n\r#%&]/g, '')
+        .trim()
+        // 空格转下划线
+        .replace(/\s+/g, '_')
+        // 移除连续的下划线
+        .replace(/_+/g, '_')
+        // 移除开头和结尾的下划线
+        .replace(/^_+|_+$/g, '');
+};
+exports.sanitizeFileName = sanitizeFileName;
+/**
+ * 从Markdown内容中移除所有图片
+ * @param content Markdown原始内容
+ * @returns 不含图片的纯文本Markdown
+ */
+function removeImagesFromMarkdown(content) {
+    // 移除标准Markdown图片语法: ![alt](url)
+    let cleaned = content.replace(/!\[.*?\]\(.*?\)/g, '');
+    // 移除HTML <img> 标签及其所有属性
+    cleaned = cleaned.replace(/<img\b[^>]*>/g, '');
+    // 移除base64编码的图片（包括各种格式）
+    cleaned = cleaned.replace(/!\[.*?\]\(data:image\/[a-z+]+;base64,[a-zA-Z0-9+/=]+\)/g, '');
+    // 移除可能的多余空行
+    cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+    return cleaned.trim();
+}
+/**
+ * 安全验证并标准化路径
+ */
+function validateAndResolvePath(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 针对Windows UNC路径做特殊处理
+        if (process.platform === 'win32' && filePath.startsWith('\\\\')) {
+            filePath = '\\\\?\\UNC\\' + filePath.substring(2);
+        }
+        const normalized = path_1.default.normalize(filePath);
+        const resolved = path_1.default.resolve(normalized);
+        // 检查文件是否存在
+        try {
+            yield fs_1.promises.access(resolved, fs_1.promises.constants.R_OK);
+        }
+        catch (error) {
+            logger_1.logger.warn(`文件不存在或不可读: ${resolved}`, error);
+            throw new Error(`文件不存在或不可读: ${resolved}`);
+        }
+        return resolved;
+    });
+}

package/dist/utils/config.js

@@ -0,0 +1,163 @@
+"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.SERVICE_CONFIG = exports.getExportsDir = exports.getStorageDir = exports.initializeProjectRoot = exports.PROJECT_ROOT = exports.getProjectRoot = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = require("path");
+const logger_1 = require("./logger");
+const context_manager_1 = require("./context-manager");
+/**
+ * 检测项目根目录
+ * 优先使用 MCP_STORAGE_DIR 环境变量，否则通过标记文件自动检测
+ */
+const detectProjectRoot = (enableLogging = false) => {
+    // 如果设置了 MCP_STORAGE_DIR 环境变量，直接使用
+    if (process.env.MCP_STORAGE_DIR) {
+        if (enableLogging) {
+            logger_1.logger.info(`使用环境变量 MCP_STORAGE_DIR: ${process.env.MCP_STORAGE_DIR}`);
+        }
+        return process.env.MCP_STORAGE_DIR;
+    }
+    // 自动检测项目根目录
+    let currentDir = process.cwd();
+    const markers = ['package.json', '.git', 'Cargo.toml', 'pyproject.toml', 'go.mod'];
+    if (enableLogging) {
+        logger_1.logger.info(`开始从当前目录检测项目根目录: ${currentDir}`);
+    }
+    // 在当前目录及父目录中查找标记文件
+    while (currentDir !== '/') {
+        for (const marker of markers) {
+            const markerPath = (0, path_1.resolve)(currentDir, marker);
+            if (fs.existsSync(markerPath)) {
+                if (enableLogging) {
+                    logger_1.logger.info(`找到项目标记文件 ${marker} 在: ${currentDir}`);
+                }
+                return currentDir;
+            }
+        }
+        // 移动到父目录
+        const parentDir = (0, path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            // 已到达文件系统根目录
+            break;
+        }
+        currentDir = parentDir;
+    }
+    // 回退：如果没有找到标记文件，使用当前工作目录
+    if (enableLogging) {
+        logger_1.logger.warn(`未找到项目标记文件，使用当前工作目录: ${process.cwd()}`);
+    }
+    return process.cwd();
+};
+// 延迟初始化项目根目录
+let _PROJECT_ROOT = null;
+const getProjectRoot = () => {
+    if (_PROJECT_ROOT === null) {
+        _PROJECT_ROOT = detectProjectRoot();
+    }
+    return _PROJECT_ROOT;
+};
+exports.getProjectRoot = getProjectRoot;
+// 为了向后兼容，保留 PROJECT_ROOT 导出（延迟初始化）
+exports.PROJECT_ROOT = (() => {
+    try {
+        return (0, exports.getProjectRoot)();
+    }
+    catch (error) {
+        console.warn("PROJECT_ROOT初始化失败，使用当前工作目录:", error);
+        return process.cwd();
+    }
+})();
+/**
+ * 初始化项目根目录
+ * 在 MCP 服务器启动时调用，确保项目根目录正确设置
+ */
+const initializeProjectRoot = () => {
+    // 强制重新检测项目根目录，启用日志记录
+    _PROJECT_ROOT = null;
+    const detectedRoot = detectProjectRoot(true);
+    _PROJECT_ROOT = detectedRoot;
+    // 设置环境变量
+    if (!process.env.MCP_STORAGE_DIR) {
+        process.env.MCP_STORAGE_DIR = detectedRoot;
+    }
+    // 缓存项目根目录
+    context_manager_1.contextManager.setCachedData("project_root", detectedRoot);
+    logger_1.logger.info(`项目根目录已设置为: ${detectedRoot}`);
+};
+exports.initializeProjectRoot = initializeProjectRoot;
+/**
+ * 从缓存获取项目根目录
+ * 如果缓存不存在，则重新检测并缓存
+ */
+const getStorageDir = () => {
+    try {
+        const cachedRoot = context_manager_1.contextManager.getCachedData("project_root");
+        if (cachedRoot) {
+            return cachedRoot + "/.aico";
+        }
+        // 缓存不存在，重新检测并设置
+        const detectedRoot = (0, exports.getProjectRoot)();
+        if (detectedRoot) {
+            context_manager_1.contextManager.setCachedData("project_root", detectedRoot);
+            return detectedRoot + "/.aico";
+        }
+    }
+    catch (error) {
+        // 如果检测失败，使用当前工作目录
+        console.warn("项目根目录检测失败，使用当前工作目录:", error);
+    }
+    // 回退到当前工作目录
+    const fallbackDir = process.cwd() + "/.aico";
+    return fallbackDir;
+};
+exports.getStorageDir = getStorageDir;
+const getExportsDir = () => {
+    const storageDir = (0, exports.getStorageDir)();
+    const exportsDir = storageDir + "/exports";
+    if (!fs.existsSync(exportsDir)) {
+        fs.mkdirSync(exportsDir, { recursive: true });
+    }
+    return exportsDir;
+};
+exports.getExportsDir = getExportsDir;
+/**
+ * 应用配置
+ */
+exports.SERVICE_CONFIG = {
+    name: "智能软件星工厂",
+    version: "0.2.0",
+    description: "软件工程化的需求分析，功能设计，代码编写，测试运行和发布部署"
+};

package/dist/utils/context-manager.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextManager = exports.ContextManager = void 0;
+const lru_cache_1 = require("lru-cache");
+class ContextManager {
+    constructor(config = {}) {
+        this.config = {
+            maxCacheSize: 1000,
+            ttl: 5 * 60 * 1000, // 5分钟
+            maxContextSize: 4000
+        };
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            invalidations: 0
+        };
+        Object.assign(this.config, config);
+        this.cache = new lru_cache_1.LRUCache({
+            max: this.config.maxCacheSize,
+            ttl: this.config.ttl,
+            updateAgeOnGet: true,
+        });
+    }
+    /**
+     * 获取或创建上下文
+     */
+    getContext(contextId_1) {
+        return __awaiter(this, arguments, void 0, function* (contextId, metadata = {}) {
+            const cacheKey = this.generateCacheKey(contextId, metadata);
+            // 尝试从缓存获取
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                this.stats.hits++;
+                return cached;
+            }
+            this.stats.misses++;
+            // 创建新上下文
+            const newContext = {
+                id: contextId,
+                metadata: Object.assign(Object.assign({}, metadata), { created: new Date().toISOString() })
+            };
+            // 添加到缓存
+            this.cache.set(cacheKey, newContext);
+            return newContext;
+        });
+    }
+    /**
+     * 更新上下文
+     */
+    updateContext(contextId, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getContext(contextId);
+            Object.assign(context.metadata, updates);
+            return context;
+        });
+    }
+    /**
+     * 使上下文失效
+     */
+    invalidateContext(contextId, metadata = {}) {
+        const cacheKey = this.generateCacheKey(contextId, metadata);
+        this.cache.delete(cacheKey);
+        this.stats.invalidations++;
+    }
+    /**
+     * 获取缓存数据
+     */
+    getCachedData(key) {
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            this.stats.hits++;
+            return cached;
+        }
+        this.stats.misses++;
+        return undefined;
+    }
+    /**
+     * 设置缓存数据
+     */
+    setCachedData(key, data) {
+        this.cache.set(key, data);
+    }
+    /**
+     * 使缓存项失效
+     */
+    invalidateCacheKey(key) {
+        this.cache.delete(key);
+        this.stats.invalidations++;
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    getStats() {
+        return Object.assign(Object.assign({}, this.stats), { size: this.cache.size, maxSize: this.config.maxCacheSize, ttl: this.config.ttl });
+    }
+    /**
+     * 生成缓存键（基于上下文ID和元数据）
+     */
+    generateCacheKey(contextId, metadata) {
+        return `${contextId}:${JSON.stringify(metadata)}`;
+    }
+}
+exports.ContextManager = ContextManager;
+// 创建单例实例
+exports.contextManager = new ContextManager();