intention-coding 0.4.0 → 0.4.3

package/dist/services/image-converter/converter.js

@@ -1,310 +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.ImageConverter = void 0;
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const sharp_1 = __importDefault(require("sharp"));
-const logger_1 = require("../../utils/logger");
-const types_1 = require("./types");
-/**
- * 图片格式转换核心服务
- * 职责：处理单张和批量图片的格式转换
- */
-class ImageConverter {
-    /**
-     * 转换图片（支持单张和批量）
-     */
-    convertImages(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const startTime = Date.now();
-            try {
-                // 验证参数
-                this.validateParams(params);
-                // 标准化输入路径
-                const inputPaths = Array.isArray(params.input_paths)
-                    ? params.input_paths
-                    : [params.input_paths];
-                logger_1.logger.info('开始图片转换', {
-                    inputCount: inputPaths.length,
-                    outputFormat: params.output_format,
-                    isBatch: inputPaths.length > 1
-                });
-                // 并行处理所有图片
-                const results = yield Promise.all(inputPaths.map(inputPath => this.convertSingleImage(inputPath, params)));
-                // 统计结果
-                const successful = results.filter(r => r.success).length;
-                const failed = results.length - successful;
-                const processingTime = Date.now() - startTime;
-                const batchResult = {
-                    results,
-                    summary: {
-                        total: results.length,
-                        successful,
-                        failed,
-                        processing_time_ms: processingTime
-                    }
-                };
-                logger_1.logger.info('图片转换完成', {
-                    total: results.length,
-                    successful,
-                    failed,
-                    processingTimeMs: processingTime
-                });
-                return batchResult;
-            }
-            catch (error) {
-                logger_1.logger.error('图片转换失败', { error, params });
-                throw error;
-            }
-        });
-    }
-    /**
-     * 转换单张图片
-     */
-    convertSingleImage(inputPath, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // 验证输入文件
-                yield this.validateInputFile(inputPath);
-                // 生成输出路径
-                const outputPath = this.generateOutputPath(inputPath, params);
-                // 确保输出目录存在
-                yield this.ensureOutputDirectory(outputPath);
-                // 获取图片元数据
-                const metadata = yield this.getImageMetadata(inputPath);
-                // 执行转换
-                const result = yield this.performConversion(inputPath, outputPath, params, metadata);
-                logger_1.logger.info('单张图片转换成功', {
-                    inputPath,
-                    outputPath,
-                    format: params.output_format
-                });
-                return result;
-            }
-            catch (error) {
-                logger_1.logger.error('单张图片转换失败', { error, inputPath });
-                return {
-                    input_path: inputPath,
-                    output_path: '',
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error)
-                };
-            }
-        });
-    }
-    /**
-     * 执行实际的图片转换
-     */
-    performConversion(inputPath, outputPath, params, metadata) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let sharpInstance = (0, sharp_1.default)(inputPath);
-            // 处理尺寸调整
-            if (params.width || params.height) {
-                const resizeOptions = {
-                    fit: params.maintain_aspect_ratio ? 'inside' : 'fill',
-                    withoutEnlargement: false
-                };
-                sharpInstance = sharpInstance.resize(params.width, params.height, resizeOptions);
-            }
-            // 根据输出格式设置选项
-            const outputFormat = params.output_format.toLowerCase();
-            switch (outputFormat) {
-                case 'jpg':
-                case 'jpeg':
-                    sharpInstance = sharpInstance.jpeg({
-                        quality: params.quality || 90,
-                        progressive: true
-                    });
-                    break;
-                case 'png':
-                    sharpInstance = sharpInstance.png({
-                        compressionLevel: params.quality ? Math.round((100 - params.quality) / 10) : 6,
-                        progressive: true
-                    });
-                    break;
-                case 'webp':
-                    sharpInstance = sharpInstance.webp({
-                        quality: params.quality || 90,
-                        effort: 4
-                    });
-                    break;
-                case 'tiff':
-                    sharpInstance = sharpInstance.tiff({
-                        quality: params.quality || 90,
-                        compression: 'lzw'
-                    });
-                    break;
-                case 'bmp':
-                    // Sharp不直接支持BMP输出，转换为PNG
-                    sharpInstance = sharpInstance.png();
-                    break;
-                case 'gif':
-                    // Sharp不直接支持GIF输出，转换为PNG
-                    sharpInstance = sharpInstance.png();
-                    break;
-                case 'ico':
-                    // 对于ICO格式，调整到合适的尺寸
-                    sharpInstance = sharpInstance.resize(32, 32, { fit: 'inside' }).png();
-                    break;
-                default:
-                    throw new types_1.ImageConversionError(`不支持的输出格式: ${outputFormat}`, types_1.ConversionErrorCodes.UNSUPPORTED_FORMAT, { format: outputFormat });
-            }
-            // 执行转换并保存
-            yield sharpInstance.toFile(outputPath);
-            // 获取转换后的图片信息
-            const outputMetadata = yield this.getImageMetadata(outputPath);
-            const stats = yield fs.stat(outputPath);
-            return {
-                input_path: inputPath,
-                output_path: outputPath,
-                success: true,
-                format: outputFormat,
-                dimensions: {
-                    width: outputMetadata.width,
-                    height: outputMetadata.height
-                },
-                file_size: stats.size
-            };
-        });
-    }
-    /**
-     * 获取图片元数据
-     */
-    getImageMetadata(imagePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const metadata = yield (0, sharp_1.default)(imagePath).metadata();
-                return {
-                    format: metadata.format || 'unknown',
-                    width: metadata.width || 0,
-                    height: metadata.height || 0,
-                    channels: metadata.channels || 0,
-                    hasAlpha: metadata.hasAlpha || false,
-                    density: metadata.density
-                };
-            }
-            catch (error) {
-                throw new types_1.ImageConversionError(`无法读取图片元数据: ${imagePath}`, types_1.ConversionErrorCodes.CONVERSION_FAILED, { imagePath, originalError: error });
-            }
-        });
-    }
-    /**
-     * 验证参数
-     */
-    validateParams(params) {
-        // 验证输出格式
-        const outputFormat = params.output_format.toLowerCase();
-        if (!types_1.SUPPORTED_OUTPUT_FORMATS.includes(outputFormat)) {
-            throw new types_1.ImageConversionError(`不支持的输出格式: ${params.output_format}`, types_1.ConversionErrorCodes.UNSUPPORTED_FORMAT, {
-                format: params.output_format,
-                supportedFormats: types_1.SUPPORTED_OUTPUT_FORMATS
-            });
-        }
-        // 验证质量参数
-        if (params.quality !== undefined && (params.quality < 1 || params.quality > 100)) {
-            throw new types_1.ImageConversionError('质量参数必须在1-100之间', types_1.ConversionErrorCodes.INVALID_QUALITY, { quality: params.quality });
-        }
-        // 验证尺寸参数
-        if (params.width !== undefined && params.width <= 0) {
-            throw new types_1.ImageConversionError('宽度必须大于0', types_1.ConversionErrorCodes.INVALID_DIMENSIONS, { width: params.width });
-        }
-        if (params.height !== undefined && params.height <= 0) {
-            throw new types_1.ImageConversionError('高度必须大于0', types_1.ConversionErrorCodes.INVALID_DIMENSIONS, { height: params.height });
-        }
-    }
-    /**
-     * 验证输入文件
-     */
-    validateInputFile(inputPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield fs.access(inputPath);
-            }
-            catch (_a) {
-                throw new types_1.ImageConversionError(`输入文件不存在: ${inputPath}`, types_1.ConversionErrorCodes.FILE_NOT_FOUND, { inputPath });
-            }
-            // 验证文件格式
-            const ext = path.extname(inputPath).slice(1).toLowerCase();
-            if (!types_1.SUPPORTED_INPUT_FORMATS.includes(ext)) {
-                throw new types_1.ImageConversionError(`不支持的输入格式: ${ext}`, types_1.ConversionErrorCodes.UNSUPPORTED_FORMAT, {
-                    format: ext,
-                    supportedFormats: types_1.SUPPORTED_INPUT_FORMATS
-                });
-            }
-        });
-    }
-    /**
-     * 生成输出路径
-     */
-    generateOutputPath(inputPath, params) {
-        const inputDir = path.dirname(inputPath);
-        const inputName = path.basename(inputPath, path.extname(inputPath));
-        const outputExt = params.output_format.toLowerCase();
-        // 如果指定了输出目录，使用输出目录
-        if (params.output_directory) {
-            return path.join(params.output_directory, `${inputName}.${outputExt}`);
-        }
-        // 否则在原文件目录生成
-        return path.join(inputDir, `${inputName}.${outputExt}`);
-    }
-    /**
-     * 确保输出目录存在
-     */
-    ensureOutputDirectory(outputPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const outputDir = path.dirname(outputPath);
-            try {
-                yield fs.mkdir(outputDir, { recursive: true });
-            }
-            catch (error) {
-                throw new types_1.ImageConversionError(`无法创建输出目录: ${outputDir}`, types_1.ConversionErrorCodes.OUTPUT_WRITE_FAILED, { outputDir, originalError: error });
-            }
-        });
-    }
-}
-exports.ImageConverter = ImageConverter;

package/dist/services/image-converter/index.js

@@ -1,262 +0,0 @@
-"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.ConversionErrorCodes = exports.ImageConversionError = exports.ImageConverter = exports.imageConverterTool = void 0;
-const zod_1 = require("zod");
-const logger_1 = require("../../utils/logger");
-const converter_1 = require("./converter");
-const types_1 = require("./types");
-// 参数验证Schema
-const ImageConversionParamsSchema = zod_1.z.object({
-    input_paths: zod_1.z
-        .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())])
-        .describe("输入图片路径，支持单个路径或路径数组"),
-    output_format: zod_1.z
-        .enum(["jpg", "jpeg", "png", "gif", "bmp", "tiff", "webp", "ico"])
-        .describe("输出格式"),
-    quality: zod_1.z
-        .number()
-        .min(1)
-        .max(100)
-        .optional()
-        .describe("图片质量，1-100，默认90"),
-    width: zod_1.z.number().positive().optional().describe("输出宽度（像素）"),
-    height: zod_1.z.number().positive().optional().describe("输出高度（像素）"),
-    maintain_aspect_ratio: zod_1.z
-        .boolean()
-        .default(true)
-        .describe("是否保持宽高比，默认true"),
-    output_directory: zod_1.z
-        .string()
-        .optional()
-        .describe("输出目录，不指定则在原文件目录生成"),
-});
-/**
- * 图片格式转换智能体
- * 支持单张图片和批量图片转换
- */
-exports.imageConverterTool = {
-    name: "图片格式转换智能体",
-    description: "专业图片格式转换工具，支持单张和批量转换，包含尺寸调整和质量控制功能",
-    parameters: ImageConversionParamsSchema,
-    execute: (args) => __awaiter(void 0, void 0, void 0, function* () {
-        const converter = new converter_1.ImageConverter();
-        try {
-            logger_1.logger.info("图片格式转换智能体开始执行", {
-                inputPaths: args.input_paths,
-                outputFormat: args.output_format,
-                isBatch: Array.isArray(args.input_paths),
-            });
-            // 转换参数格式
-            const conversionParams = {
-                input_paths: args.input_paths,
-                output_format: args.output_format,
-                quality: args.quality,
-                width: args.width,
-                height: args.height,
-                maintain_aspect_ratio: args.maintain_aspect_ratio,
-                output_directory: args.output_directory,
-            };
-            // 执行转换
-            const result = yield converter.convertImages(conversionParams);
-            // 格式化返回结果
-            return formatConversionResult(result, args);
-        }
-        catch (error) {
-            logger_1.logger.error("图片格式转换智能体执行失败", { error, args });
-            if (error instanceof types_1.ImageConversionError) {
-                return formatErrorResponse(error);
-            }
-            return formatUnknownErrorResponse(error);
-        }
-    }),
-};
-/**
- * 格式化转换结果
- */
-function formatConversionResult(result, args) {
-    const { summary, results } = result;
-    const isBatch = Array.isArray(args.input_paths);
-    if (summary.failed === 0) {
-        // 全部成功
-        return `
-# ✅ 图片格式转换完成
-
-## 📊 转换统计
-- **处理模式**: ${isBatch ? "批量转换" : "单张转换"}
-- **总计图片**: ${summary.total} 张
-- **成功转换**: ${summary.successful} 张
-- **转换失败**: ${summary.failed} 张
-- **处理时间**: ${summary.processing_time_ms}ms
-- **目标格式**: ${args.output_format.toUpperCase()}
-
-## 📁 转换结果
-
-${results
-            .map((r, index) => {
-            var _a, _b, _c;
-            return `
-### ${index + 1}. ${getFileName(r.input_path)}
-- **输入**: \`${r.input_path}\`
-- **输出**: \`${r.output_path}\`
-- **格式**: ${(_a = r.format) === null || _a === void 0 ? void 0 : _a.toUpperCase()}
-- **尺寸**: ${(_b = r.dimensions) === null || _b === void 0 ? void 0 : _b.width} × ${(_c = r.dimensions) === null || _c === void 0 ? void 0 : _c.height}
-- **文件大小**: ${formatFileSize(r.file_size || 0)}
-`;
-        })
-            .join("")}
-
-${args.width || args.height
-            ? `
-## 🔧 尺寸调整
-- **目标尺寸**: ${args.width || "自动"} × ${args.height || "自动"}
-- **保持宽高比**: ${args.maintain_aspect_ratio ? "是" : "否"}
-`
-            : ""}
-
-${args.quality
-            ? `
-## 🎨 质量设置
-- **压缩质量**: ${args.quality}%
-`
-            : ""}
-
-**所有图片转换成功完成！**
-    `.trim();
-    }
-    else {
-        // 部分失败
-        const successResults = results.filter((r) => r.success);
-        const failedResults = results.filter((r) => !r.success);
-        return `
-# ⚠️ 图片格式转换部分完成
-
-## 📊 转换统计
-- **处理模式**: ${isBatch ? "批量转换" : "单张转换"}
-- **总计图片**: ${summary.total} 张
-- **成功转换**: ${summary.successful} 张
-- **转换失败**: ${summary.failed} 张
-- **成功率**: ${((summary.successful / summary.total) * 100).toFixed(1)}%
-- **处理时间**: ${summary.processing_time_ms}ms
-
-## ✅ 成功转换 (${successResults.length}张)
-
-${successResults
-            .map((r, index) => {
-            var _a, _b;
-            return `
-${index + 1}. **${getFileName(r.input_path)}**
-   - 输出: \`${r.output_path}\`
-   - 尺寸: ${(_a = r.dimensions) === null || _a === void 0 ? void 0 : _a.width} × ${(_b = r.dimensions) === null || _b === void 0 ? void 0 : _b.height}
-   - 大小: ${formatFileSize(r.file_size || 0)}
-`;
-        })
-            .join("")}
-
-## ❌ 转换失败 (${failedResults.length}张)
-
-${failedResults
-            .map((r, index) => `
-${index + 1}. **${getFileName(r.input_path)}**
-   - 错误: ${r.error}
-`)
-            .join("")}
-
-**请检查失败的图片并重试。**
-    `.trim();
-    }
-}
-/**
- * 格式化错误响应
- */
-function formatErrorResponse(error) {
-    const errorMessages = {
-        [types_1.ConversionErrorCodes.INVALID_INPUT_PATH]: "输入路径无效",
-        [types_1.ConversionErrorCodes.UNSUPPORTED_FORMAT]: "不支持的格式",
-        [types_1.ConversionErrorCodes.FILE_NOT_FOUND]: "文件未找到",
-        [types_1.ConversionErrorCodes.INVALID_DIMENSIONS]: "无效的尺寸参数",
-        [types_1.ConversionErrorCodes.CONVERSION_FAILED]: "转换失败",
-        [types_1.ConversionErrorCodes.OUTPUT_WRITE_FAILED]: "输出写入失败",
-        [types_1.ConversionErrorCodes.INVALID_QUALITY]: "无效的质量参数",
-    };
-    const errorTitle = errorMessages[error.code] || "转换错误";
-    return `
-# ❌ ${errorTitle}
-
-## 错误信息
-${error.message}
-
-## 错误代码
-${error.code}
-
-## 解决建议
-${getErrorSuggestion(error.code)}
-
-## 支持的格式
-- **输入格式**: ${types_1.SUPPORTED_INPUT_FORMATS.join(", ")}
-- **输出格式**: ${types_1.SUPPORTED_OUTPUT_FORMATS.join(", ")}
-
-## 错误详情
-- **时间**: ${new Date().toISOString()}
-- **上下文**: ${error.context ? JSON.stringify(error.context, null, 2) : "无"}
-
-请根据上述信息调整参数后重试。
-  `.trim();
-}
-/**
- * 格式化未知错误响应
- */
-function formatUnknownErrorResponse(error) {
-    return `
-# ❌ 系统错误
-
-图片转换过程中发生未知错误，请稍后重试或联系技术支持。
-
-**错误信息**: ${(error === null || error === void 0 ? void 0 : error.message) || "未知错误"}
-**时间**: ${new Date().toISOString()}
-
-## 建议
-1. 检查输入文件是否存在且可读
-2. 确认输出目录有写入权限
-3. 验证图片文件是否损坏
-4. 如问题持续，请联系技术支持
-  `.trim();
-}
-// 辅助函数
-function getFileName(filePath) {
-    return filePath.split("/").pop() || filePath;
-}
-function 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]}`;
-}
-function getErrorSuggestion(errorCode) {
-    const suggestions = {
-        [types_1.ConversionErrorCodes.INVALID_INPUT_PATH]: "请检查输入路径是否正确",
-        [types_1.ConversionErrorCodes.UNSUPPORTED_FORMAT]: "请使用支持的图片格式",
-        [types_1.ConversionErrorCodes.FILE_NOT_FOUND]: "请确认文件存在且路径正确",
-        [types_1.ConversionErrorCodes.INVALID_DIMENSIONS]: "请提供有效的宽度和高度值（大于0）",
-        [types_1.ConversionErrorCodes.CONVERSION_FAILED]: "请检查图片文件是否损坏",
-        [types_1.ConversionErrorCodes.OUTPUT_WRITE_FAILED]: "请检查输出目录权限",
-        [types_1.ConversionErrorCodes.INVALID_QUALITY]: "请设置1-100之间的质量值",
-    };
-    return suggestions[errorCode] || "请检查输入参数并重试";
-}
-// 导出类型和服务
-var converter_2 = require("./converter");
-Object.defineProperty(exports, "ImageConverter", { enumerable: true, get: function () { return converter_2.ImageConverter; } });
-var types_2 = require("./types");
-Object.defineProperty(exports, "ImageConversionError", { enumerable: true, get: function () { return types_2.ImageConversionError; } });
-Object.defineProperty(exports, "ConversionErrorCodes", { enumerable: true, get: function () { return types_2.ConversionErrorCodes; } });

package/dist/services/image-converter/types.js

@@ -1,31 +0,0 @@
-"use strict";
-/**
- * 图片格式转换智能体的类型定义
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_OUTPUT_FORMATS = exports.SUPPORTED_INPUT_FORMATS = exports.ConversionErrorCodes = exports.ImageConversionError = void 0;
-class ImageConversionError extends Error {
-    constructor(message, code, context) {
-        super(message);
-        this.code = code;
-        this.context = context;
-        this.name = 'ImageConversionError';
-    }
-}
-exports.ImageConversionError = ImageConversionError;
-var ConversionErrorCodes;
-(function (ConversionErrorCodes) {
-    ConversionErrorCodes["INVALID_INPUT_PATH"] = "INVALID_INPUT_PATH";
-    ConversionErrorCodes["UNSUPPORTED_FORMAT"] = "UNSUPPORTED_FORMAT";
-    ConversionErrorCodes["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
-    ConversionErrorCodes["INVALID_DIMENSIONS"] = "INVALID_DIMENSIONS";
-    ConversionErrorCodes["CONVERSION_FAILED"] = "CONVERSION_FAILED";
-    ConversionErrorCodes["OUTPUT_WRITE_FAILED"] = "OUTPUT_WRITE_FAILED";
-    ConversionErrorCodes["INVALID_QUALITY"] = "INVALID_QUALITY";
-})(ConversionErrorCodes || (exports.ConversionErrorCodes = ConversionErrorCodes = {}));
-exports.SUPPORTED_INPUT_FORMATS = [
-    'jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'tif', 'webp', 'svg', 'ico'
-];
-exports.SUPPORTED_OUTPUT_FORMATS = [
-    'jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp', 'ico'
-];