intention-coding 0.3.7 → 0.4.0

package/dist/services/image-analysis/analyzer.js

@@ -0,0 +1,530 @@
+"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.ImageAnalyzer = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+const openai_1 = require("../../utils/openai");
+const logger_1 = require("../../utils/logger");
+const types_1 = require("./types");
+/**
+ * 图片内容理解核心服务
+ * 职责：分析图片内容并提供智能理解
+ */
+class ImageAnalyzer {
+    /**
+     * 分析图片内容
+     */
+    analyzeImage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            try {
+                logger_1.logger.info('开始图片内容分析', {
+                    imagePath: params.image_path,
+                    analysisType: params.analysis_type,
+                    detailLevel: params.detail_level
+                });
+                // 验证参数和文件
+                yield this.validateParams(params);
+                // 获取图片基本信息
+                const basicInfo = yield this.getImageBasicInfo(params.image_path);
+                // 执行AI分析
+                const analysisContent = yield this.performAIAnalysis(params, basicInfo);
+                const processingTime = Date.now() - startTime;
+                const result = {
+                    basic_info: basicInfo,
+                    analysis_type: params.analysis_type,
+                    detail_level: params.detail_level || types_1.DetailLevel.DETAILED,
+                    content: analysisContent,
+                    processing_time_ms: processingTime,
+                    confidence_score: this.calculateConfidenceScore(analysisContent)
+                };
+                logger_1.logger.info('图片内容分析完成', {
+                    imagePath: params.image_path,
+                    processingTimeMs: processingTime,
+                    confidenceScore: result.confidence_score
+                });
+                return result;
+            }
+            catch (error) {
+                logger_1.logger.error('图片内容分析失败', { error, params });
+                throw error;
+            }
+        });
+    }
+    /**
+     * 执行AI分析
+     */
+    performAIAnalysis(params, basicInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 将图片转换为base64
+                const imageBase64 = yield this.imageToBase64(params.image_path);
+                // 构建分析prompt
+                const prompt = this.buildAnalysisPrompt(params, basicInfo);
+                // 调用AI服务
+                const aiResponse = yield openai_1.openAIService.analyzeImage({
+                    image_base64: imageBase64,
+                    prompt: prompt
+                });
+                // 解析AI响应
+                const analysisContent = this.parseAIResponse(aiResponse, params.analysis_type);
+                return analysisContent;
+            }
+            catch (error) {
+                logger_1.logger.error('AI分析失败', { error, params });
+                throw new types_1.ImageAnalysisError('AI图片分析服务调用失败', types_1.AnalysisErrorCodes.AI_SERVICE_ERROR, { originalError: error });
+            }
+        });
+    }
+    /**
+     * 构建分析prompt
+     */
+    buildAnalysisPrompt(params, basicInfo) {
+        const basePrompt = `请分析这张图片，图片信息：
+- 格式：${basicInfo.format}
+- 尺寸：${basicInfo.dimensions.width} × ${basicInfo.dimensions.height}
+- 文件大小：${this.formatFileSize(basicInfo.file_size)}`;
+        let specificPrompt = '';
+        switch (params.analysis_type) {
+            case types_1.AnalysisType.GENERAL:
+                specificPrompt = '请提供图片的全面描述，包括主要内容、场景、物体、颜色、构图等。';
+                break;
+            case types_1.AnalysisType.OBJECTS:
+                specificPrompt = '请识别图片中的所有物体，包括物体名称、位置、大小、特征等详细信息。';
+                break;
+            case types_1.AnalysisType.TEXT:
+                specificPrompt = '请提取图片中的所有文字内容，包括文字位置、字体、语言等信息。';
+                break;
+            case types_1.AnalysisType.SCENE:
+                specificPrompt = '请分析图片的场景信息，包括地点类型、环境、光照、天气、时间、氛围等。';
+                break;
+            case types_1.AnalysisType.PEOPLE:
+                specificPrompt = '请分析图片中的人物信息，包括人数、年龄、性别、表情、动作、服装等。';
+                break;
+            case types_1.AnalysisType.TECHNICAL:
+                specificPrompt = '请从技术角度分析图片，包括色彩分析、构图分析、质量评估等专业信息。';
+                break;
+            case types_1.AnalysisType.UI_DESIGN:
+                specificPrompt = `请分析这张UI设计稿，重点关注以下方面：
+1. 页面布局结构和组件层次
+2. 导航设计和信息架构
+3. 色彩搭配和视觉风格
+4. 交互元素和用户体验设计
+5. 响应式设计考虑
+6. 可访问性特征
+7. 设计模式和最佳实践
+请提供详细的UI结构图和页面结构分析。`;
+                break;
+            case types_1.AnalysisType.REQUIREMENT:
+                specificPrompt = `请从需求分析角度分析这张图片，识别和提取以下信息：
+1. 功能需求：识别图片中体现的功能点和业务逻辑
+2. 用户故事：基于图片内容推导用户需求和使用场景
+3. 非功能需求：性能、安全、可用性等方面的要求
+4. 业务规则：从图片中识别的业务约束和规则
+5. 系统边界：确定系统范围和外部接口
+6. 数据需求：识别需要处理的数据类型和结构
+请提供结构化的需求分析报告。`;
+                break;
+            case types_1.AnalysisType.CUSTOM:
+                specificPrompt = params.custom_prompt || '请分析这张图片的内容。';
+                break;
+        }
+        const detailInstruction = this.getDetailInstruction(params.detail_level);
+        const languageInstruction = params.language ? `请用${params.language}回答。` : '';
+        return `${basePrompt}\n\n${specificPrompt}\n\n${detailInstruction}\n\n${languageInstruction}`.trim();
+    }
+    /**
+     * 获取详细程度指令
+     */
+    getDetailInstruction(detailLevel) {
+        switch (detailLevel) {
+            case types_1.DetailLevel.BRIEF:
+                return '请提供简要的分析结果，重点突出最重要的信息。';
+            case types_1.DetailLevel.COMPREHENSIVE:
+                return '请提供全面详细的分析结果，包含所有可能的细节和专业见解。';
+            case types_1.DetailLevel.DETAILED:
+            default:
+                return '请提供详细的分析结果，包含主要特征和重要细节。';
+        }
+    }
+    /**
+     * 解析AI响应
+     */
+    parseAIResponse(aiResponse, analysisType) {
+        // 基础内容结构
+        const content = {
+            summary: aiResponse,
+            details: {},
+            tags: this.extractTags(aiResponse)
+        };
+        // 根据分析类型解析特定内容
+        switch (analysisType) {
+            case types_1.AnalysisType.OBJECTS:
+                content.objects = this.extractObjects(aiResponse);
+                break;
+            case types_1.AnalysisType.TEXT:
+                content.text_content = this.extractTextContent(aiResponse);
+                break;
+            case types_1.AnalysisType.SCENE:
+                content.scene_info = this.extractSceneInfo(aiResponse);
+                break;
+            case types_1.AnalysisType.PEOPLE:
+                content.people_info = this.extractPeopleInfo(aiResponse);
+                break;
+            case types_1.AnalysisType.TECHNICAL:
+                content.technical_info = this.extractTechnicalInfo(aiResponse);
+                break;
+            case types_1.AnalysisType.UI_DESIGN:
+                content.ui_design_info = this.extractUIDesignInfo(aiResponse);
+                break;
+            case types_1.AnalysisType.REQUIREMENT:
+                content.requirement_info = this.extractRequirementInfo(aiResponse);
+                break;
+        }
+        return content;
+    }
+    /**
+     * 获取图片基本信息
+     */
+    getImageBasicInfo(imagePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const metadata = yield (0, sharp_1.default)(imagePath).metadata();
+                const stats = yield fs.stat(imagePath);
+                return {
+                    path: imagePath,
+                    format: metadata.format || 'unknown',
+                    dimensions: {
+                        width: metadata.width || 0,
+                        height: metadata.height || 0
+                    },
+                    file_size: stats.size,
+                    color_space: metadata.space,
+                    has_alpha: metadata.hasAlpha
+                };
+            }
+            catch (error) {
+                throw new types_1.ImageAnalysisError(`无法读取图片信息: ${imagePath}`, types_1.AnalysisErrorCodes.IMAGE_CORRUPTED, { imagePath, originalError: error });
+            }
+        });
+    }
+    /**
+     * 将图片转换为base64 data URL
+     */
+    imageToBase64(imagePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const imageBuffer = yield fs.readFile(imagePath);
+                const base64 = imageBuffer.toString('base64');
+                // 获取文件扩展名来确定 MIME 类型
+                const ext = path.extname(imagePath).toLowerCase();
+                let mimeType = 'image/jpeg'; // 默认
+                switch (ext) {
+                    case '.png':
+                        mimeType = 'image/png';
+                        break;
+                    case '.gif':
+                        mimeType = 'image/gif';
+                        break;
+                    case '.webp':
+                        mimeType = 'image/webp';
+                        break;
+                    case '.jpg':
+                    case '.jpeg':
+                        mimeType = 'image/jpeg';
+                        break;
+                    default:
+                        mimeType = 'image/jpeg';
+                }
+                // 返回完整的 data URL 格式
+                return `data:${mimeType};base64,${base64}`;
+            }
+            catch (error) {
+                throw new types_1.ImageAnalysisError(`无法读取图片文件: ${imagePath}`, types_1.AnalysisErrorCodes.FILE_NOT_FOUND, { imagePath, originalError: error });
+            }
+        });
+    }
+    /**
+     * 验证参数
+     */
+    validateParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 验证文件存在
+            try {
+                yield fs.access(params.image_path);
+            }
+            catch (_a) {
+                throw new types_1.ImageAnalysisError(`图片文件不存在: ${params.image_path}`, types_1.AnalysisErrorCodes.FILE_NOT_FOUND, { imagePath: params.image_path });
+            }
+            // 验证文件格式
+            const ext = path.extname(params.image_path).slice(1).toLowerCase();
+            if (!types_1.SUPPORTED_IMAGE_FORMATS.includes(ext)) {
+                throw new types_1.ImageAnalysisError(`不支持的图片格式: ${ext}`, types_1.AnalysisErrorCodes.UNSUPPORTED_FORMAT, {
+                    format: ext,
+                    supportedFormats: types_1.SUPPORTED_IMAGE_FORMATS
+                });
+            }
+            // 验证分析类型
+            if (!Object.values(types_1.AnalysisType).includes(params.analysis_type)) {
+                throw new types_1.ImageAnalysisError(`无效的分析类型: ${params.analysis_type}`, types_1.AnalysisErrorCodes.INVALID_ANALYSIS_TYPE, { analysisType: params.analysis_type });
+            }
+            // 验证自定义分析的prompt
+            if (params.analysis_type === types_1.AnalysisType.CUSTOM && !params.custom_prompt) {
+                throw new types_1.ImageAnalysisError('自定义分析类型需要提供custom_prompt参数', types_1.AnalysisErrorCodes.INVALID_ANALYSIS_TYPE, { analysisType: params.analysis_type });
+            }
+        });
+    }
+    /**
+     * 计算置信度分数
+     */
+    calculateConfidenceScore(content) {
+        // 基于内容长度和结构化程度计算置信度
+        let score = 0.5; // 基础分数
+        if (content.summary.length > 100)
+            score += 0.2;
+        if (content.tags && content.tags.length > 0)
+            score += 0.1;
+        if (content.objects && content.objects.length > 0)
+            score += 0.1;
+        if (content.text_content && content.text_content.length > 0)
+            score += 0.1;
+        return Math.min(score, 1.0);
+    }
+    // 内容提取辅助方法
+    extractTags(text) {
+        // 简单的标签提取逻辑
+        const tagPatterns = [
+            /标签[：:]\s*([^\n]+)/i,
+            /关键词[：:]\s*([^\n]+)/i,
+            /tags[：:]\s*([^\n]+)/i
+        ];
+        for (const pattern of tagPatterns) {
+            const match = text.match(pattern);
+            if (match) {
+                return match[1].split(/[,，、]/).map(tag => tag.trim()).filter(Boolean);
+            }
+        }
+        return [];
+    }
+    extractObjects(text) {
+        // 简化的物体提取逻辑
+        return [];
+    }
+    extractTextContent(text) {
+        // 简化的文字提取逻辑
+        return [];
+    }
+    extractSceneInfo(text) {
+        // 简化的场景信息提取逻辑
+        return {};
+    }
+    extractPeopleInfo(text) {
+        // 简化的人物信息提取逻辑
+        return [];
+    }
+    extractTechnicalInfo(text) {
+        // 简化的技术信息提取逻辑
+        return {};
+    }
+    extractUIDesignInfo(text) {
+        // UI设计信息提取逻辑
+        const uiInfo = {
+            layout_type: this.extractValue(text, /布局类型[：:]\s*([^\n]+)/i) || '未识别',
+            components: this.extractUIComponents(text),
+            color_scheme: this.extractColorScheme(text),
+            typography: this.extractTypography(text),
+            navigation: this.extractNavigation(text),
+            responsive_design: this.extractBoolean(text, /响应式|自适应/i),
+            design_patterns: this.extractList(text, /设计模式[：:]\s*([^\n]+)/i),
+            accessibility_features: this.extractList(text, /可访问性[：:]\s*([^\n]+)/i)
+        };
+        return uiInfo;
+    }
+    extractRequirementInfo(text) {
+        // 需求信息提取逻辑
+        const reqInfo = {
+            functional_requirements: this.extractFunctionalRequirements(text),
+            non_functional_requirements: this.extractNonFunctionalRequirements(text),
+            user_stories: this.extractUserStories(text),
+            business_rules: this.extractList(text, /业务规则[：:]\s*([^\n]+)/i),
+            constraints: this.extractList(text, /约束条件[：:]\s*([^\n]+)/i),
+            assumptions: this.extractList(text, /假设条件[：:]\s*([^\n]+)/i)
+        };
+        return reqInfo;
+    }
+    // 辅助提取方法
+    extractValue(text, pattern) {
+        const match = text.match(pattern);
+        return match ? match[1].trim() : null;
+    }
+    extractBoolean(text, pattern) {
+        return pattern.test(text);
+    }
+    extractList(text, pattern) {
+        const match = text.match(pattern);
+        if (match) {
+            return match[1].split(/[,，、]/).map(item => item.trim()).filter(Boolean);
+        }
+        return [];
+    }
+    extractUIComponents(text) {
+        // 简化的UI组件提取逻辑
+        const components = [];
+        const componentPatterns = [
+            /按钮|button/gi,
+            /输入框|input|文本框/gi,
+            /导航|navigation|nav/gi,
+            /卡片|card/gi,
+            /列表|list/gi,
+            /表格|table/gi
+        ];
+        componentPatterns.forEach((pattern, index) => {
+            const matches = text.match(pattern);
+            if (matches) {
+                components.push({
+                    type: ['button', 'input', 'navigation', 'card', 'list', 'table'][index],
+                    name: matches[0],
+                    position: { x: 0, y: 0, width: 0, height: 0 },
+                    properties: {}
+                });
+            }
+        });
+        return components;
+    }
+    extractColorScheme(text) {
+        return {
+            primary_colors: this.extractList(text, /主色调[：:]\s*([^\n]+)/i),
+            secondary_colors: this.extractList(text, /辅助色[：:]\s*([^\n]+)/i),
+            background_colors: this.extractList(text, /背景色[：:]\s*([^\n]+)/i)
+        };
+    }
+    extractTypography(text) {
+        return {
+            fonts: this.extractList(text, /字体[：:]\s*([^\n]+)/i),
+            text_hierarchy: this.extractList(text, /文字层次[：:]\s*([^\n]+)/i)
+        };
+    }
+    extractNavigation(text) {
+        return {
+            type: this.extractValue(text, /导航类型[：:]\s*([^\n]+)/i) || '未识别',
+            elements: this.extractList(text, /导航元素[：:]\s*([^\n]+)/i)
+        };
+    }
+    extractFunctionalRequirements(text) {
+        // 简化的功能需求提取逻辑
+        const requirements = [];
+        const funcReqPattern = /功能需求[：:][\s\S]*?(?=非功能需求|用户故事|$)/i;
+        const match = text.match(funcReqPattern);
+        if (match) {
+            const reqText = match[0];
+            const reqItems = reqText.split(/\d+\./).filter(item => item.trim());
+            reqItems.forEach((item, index) => {
+                if (item.trim()) {
+                    requirements.push({
+                        id: `FR-${index + 1}`,
+                        title: item.split('\n')[0].trim(),
+                        description: item.trim(),
+                        priority: 'medium',
+                        category: '功能需求',
+                        acceptance_criteria: []
+                    });
+                }
+            });
+        }
+        return requirements;
+    }
+    extractNonFunctionalRequirements(text) {
+        // 简化的非功能需求提取逻辑
+        const requirements = [];
+        const nfrTypes = ['性能', '安全', '可用性', '可维护性', '可扩展性'];
+        nfrTypes.forEach(type => {
+            const pattern = new RegExp(`${type}[：:]\\s*([^\\n]+)`, 'i');
+            const match = text.match(pattern);
+            if (match) {
+                requirements.push({
+                    type: type,
+                    description: match[1].trim(),
+                    metric: '',
+                    target_value: ''
+                });
+            }
+        });
+        return requirements;
+    }
+    extractUserStories(text) {
+        // 简化的用户故事提取逻辑
+        const stories = [];
+        const storyPattern = /作为.*?我希望.*?以便.*?/g;
+        const matches = text.match(storyPattern);
+        if (matches) {
+            matches.forEach((story, index) => {
+                const parts = story.split(/我希望|以便/);
+                if (parts.length >= 3) {
+                    stories.push({
+                        as_a: parts[0].replace('作为', '').trim(),
+                        i_want: parts[1].trim(),
+                        so_that: parts[2].trim(),
+                        acceptance_criteria: [],
+                        priority: 'medium'
+                    });
+                }
+            });
+        }
+        return stories;
+    }
+    formatFileSize(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+    }
+}
+exports.ImageAnalyzer = ImageAnalyzer;