intention-coding 0.3.8 → 0.4.1

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

@@ -1,530 +0,0 @@
-"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;