scancscode 1.0.41 → 1.0.43

package/.trae/documents/csv_auto_translator_plan.md

@@ -0,0 +1,59 @@
+# CSV自动翻译器 - 实现计划
+
+## [ ] Task 1: 实现小牛翻译API客户端
+- **Priority**: P0
+- **Depends On**: None
+- **Description**: 
+  - 实现权限字符串生成（按ASCII码排序参数字段 + MD5加密）
+  - 实现批量翻译API调用
+  - 支持API Key、AppId配置
+- **Success Criteria**:
+  - 能正确生成符合小牛API规范的authStr
+  - 能成功调用小牛翻译批量接口并返回结果
+- **Test Requirements**:
+  - `programmatic` TR-1.1: authStr生成算法符合文档规范
+  - `programmatic` TR-1.2: API调用能处理响应和错误
+- **Notes**: 使用Node.js内置crypto模块实现MD5
+
+## [ ] Task 2: 实现CSV读取和解析逻辑
+- **Priority**: P0
+- **Depends On**: None
+- **Description**: 
+  - 使用现有的CSVUtils类读取CSV文件
+  - 提取第一列内容作为待翻译文本
+  - 检查第三列是否已有内容，跳过已有内容的行
+- **Success Criteria**:
+  - 能正确读取CSV文件并解析为二维数组
+  - 能正确识别需要翻译的行（第三列为空的行）
+- **Test Requirements**:
+  - `programmatic` TR-2.1: 能正确解析CSV文件
+  - `programmatic` TR-2.2: 能正确跳过第三列已有内容的行
+
+## [ ] Task 3: 实现批量翻译和CSV写入
+- **Priority**: P0
+- **Depends On**: Task 1, Task 2
+- **Description**: 
+  - 分批翻译待翻译文本（考虑API限制，每批最多50条）
+  - 将翻译结果写入第三列
+  - 保存更新后的CSV文件
+- **Success Criteria**:
+  - 翻译结果正确写入CSV第三列
+  - 已有内容的行不被覆盖
+  - 分批处理符合API限制
+- **Test Requirements**:
+  - `programmatic` TR-3.1: 翻译结果正确写入
+  - `programmatic` TR-3.2: 已有内容不被覆盖
+  - `programmatic` TR-3.3: 分批处理正常工作
+
+## [ ] Task 4: 集成和主入口
+- **Priority**: P1
+- **Depends On**: Task 3
+- **Description**: 
+  - 整合所有功能
+  - 提供清晰的类接口
+- **Success Criteria**:
+  - 完整的CsvAutoTranslator类
+  - 易于使用的API
+- **Test Requirements**:
+  - `programmatic` TR-4.1: 代码可以正常编译
+  - `human-judgment` TR-4.2: 代码风格与项目保持一致

package/.trae/documents/optimize_batching_plan.md

@@ -0,0 +1,60 @@
+# 智能分批算法优化 - 实现计划
+
+## [x] Task 1: 实现简化的单文本 JSON 长度估算函数
+- **Priority**: P0
+- **Depends On**: None
+- **Description**: 
+  - 实现 `estimateSingleTextJsonSize` 函数
+  - 基于 string.length 粗略估算单个文本的 JSON 字节长度
+  - 考虑 JSON 转义开销
+- **Success Criteria**:
+  - 能快速估算单个文本的 JSON 长度
+- **Test Requirements**:
+  - `programmatic` TR-1.1: 简单文本估算正确
+  - `programmatic` TR-1.2: 含特殊字符文本估算合理
+- **Status**: 已完成
+
+## [x] Task 2: 实现优化的 estimateJsonSize 函数
+- **Priority**: P0
+- **Depends On**: Task 1
+- **Description**: 
+  - 基于取巧原理优化 estimateJsonSize
+  - texts 的 json byteLength = 所有单 text 的 json byteLength 加和 + [] 的长度(2)
+  - 考虑逗号分隔符(每个 text 之间 1 字节)
+- **Success Criteria**:
+  - 估算结果接近真实值
+  - 性能比 JSON.stringify 更快
+- **Test Requirements**:
+  - `programmatic` TR-2.1: 估算结果误差在可接受范围
+  - `programmatic` TR-2.2: 不使用真实 JSON.stringify
+- **Status**: 已完成
+
+## [x] Task 3: 重构 smartBatch 函数使用优化算法
+- **Priority**: P0
+- **Depends On**: Task 2
+- **Description**: 
+  - 先用 string.length 粗略预估批量大小
+  - 从后往前逐 text 预估 json 长度，逐步求减
+  - 保持 500 条和 4900 字节的限制
+- **Success Criteria**:
+  - 分批算法更高效
+  - 保持原有功能不变
+- **Test Requirements**:
+  - `programmatic` TR-3.1: 每批不超过 500 条
+  - `programmatic` TR-3.2: 每批不超过 4900 字节
+  - `programmatic` TR-3.3: 分批顺序正确
+- **Status**: 已完成
+
+## [x] Task 4: 验证和性能测试
+- **Priority**: P1
+- **Depends On**: Task 3
+- **Description**: 
+  - 验证优化后的功能正常
+  - 对比性能改进
+- **Success Criteria**:
+  - 功能正常
+  - 性能有提升
+- **Test Requirements**:
+  - `programmatic` TR-4.1: TypeScript 编译无错误
+  - `programmatic` TR-4.2: 完整功能测试通过
+- **Status**: 已完成

package/.trae/specs/refactor-translate-all/checklist.md

@@ -0,0 +1,11 @@
+# translateAll 函数重构 - 验证检查清单
+
+- [x] JSON字节长度预测函数实现正确
+- [x] 智能分批算法每批不超过500条
+- [x] 智能分批算法每批JSON不超过4900字节
+- [x] 并发请求控制实现正确
+- [x] 最多同时发起不超过 this.maxBatchSize 个请求
+- [x] 翻译结果顺序与输入一致
+- [x] 代码风格与项目保持一致
+- [x] TypeScript编译无错误
+- [x] 原有功能保持不变

package/.trae/specs/refactor-translate-all/spec.md

@@ -0,0 +1,66 @@
+# translateAll 函数重构 - 产品需求文档
+
+## Overview
+- **Summary**: 重构 `translateAll` 函数，实现智能分批和并发控制，优化小牛翻译API的调用效率
+- **Purpose**: 根据小牛翻译API的限制条件，智能分批文本内容，确保请求不超过API容量限制，同时支持并发请求提高翻译效率
+- **Target Users**: 使用 CsvAutoTranslator 类的开发者和使用者
+
+## Goals
+- 实现智能分批算法，预测JSON字节长度
+- 确保每批不超过500条文本
+- 确保每批JSON字节长度不超过4900字节
+- 支持最多 `this.maxBatchSize 并发请求
+- 保持原有的功能不变
+
+## Non-Goals (Out of Scope)
+- 不修改其他函数的功能
+- 不改变API调用接口
+- 不修改其他类的结构
+
+## Background & Context
+- 小牛翻译API有以下限制：
+  - 请求长度：5000字节
+  - 列表大小：50条（原有限制）
+- 当前代码简单按50条分批，没有考虑文本长度
+- 需要智能分批可以更高效利用API
+
+## Functional Requirements
+- **FR-1**: 实现JSON字节长度预测功能
+- **FR-2**: 实现智能分批算法
+- **FR-3**: 实现并发请求控制
+
+## Non-Functional Requirements
+- **NFR-1**: 分批算法高效，不显著增加处理时间
+- **NFR-2**: 保持代码简洁易读
+
+## Constraints
+- **Technical**: TypeScript, Node.js
+- **Dependencies**: 小牛翻译API
+- **API限制**: 请求JSON长度≤5000字节，每批≤500条
+
+## Assumptions
+- JSON序列化后的字节长度预测合理
+- 原有maxBatchSize为50（并发数）
+
+## Acceptance Criteria
+
+### AC-1: 智能分批功能
+- **Given**: 有大量待翻译文本
+- **When**: 调用 translateAll 函数
+- **Then**: 文本被智能分批，每批不超过500条，且JSON字节长度不超过4900字节
+- **Verification**: `programmatic`
+
+### AC-2: 并发控制功能
+- **Given**: 有多批待翻译文本
+- **When**: 调用 translateAll 函数
+- **Then**: 同时进行最多 this.maxBatchSize 个并发请求
+- **Verification**: `programmatic`
+
+### AC-3: 功能不变
+- **Given**: 有文本需要翻译
+- **When**: 调用 translateAll 函数
+- **Then**: 返回正确的翻译结果，顺序与输入一致
+- **Verification**: `programmatic`
+
+## Open Questions
+- 无

package/.trae/specs/refactor-translate-all/tasks.md

@@ -0,0 +1,49 @@
+# translateAll 函数重构 - 实现计划
+
+## [x] Task 1: 实现JSON字节长度预测函数
+- **Priority**: P0
+- **Depends On**: None
+- **Description**: 
+  - 实现 estimateJsonSize 函数，预测一批文本转JSON后的字节长度
+  - 考虑 srcText 数组的JSON序列化开销
+- **Acceptance Criteria Addressed**: [AC-1]
+- **Test Requirements**:
+  - `programmatic` TR-1.1: 能正确预测简单文本的JSON大小
+  - `programmatic` TR-1.2: 预测结果接近实际序列化大小
+- **Status**: 已完成
+
+## [x] Task 2: 实现智能分批算法
+- **Priority**: P0
+- **Depends On**: Task 1
+- **Description**: 
+  - 实现 smartBatch 函数，根据文本列表智能分批
+  - 每批不超过500条，且JSON字节不超过4900
+  - 从 texts 依序截取
+- **Acceptance Criteria Addressed**: [AC-1]
+- **Test Requirements**:
+  - `programmatic` TR-2.1: 每批数量不超过500条
+  - `programmatic` TR-2.2: 每批JSON大小不超过4900字节
+- **Status**: 已完成
+
+## [x] Task 3: 实现并发请求控制
+- **Priority**: P0
+- **Depends On**: Task 2
+- **Description**: 
+  - 实现并发请求调度，最多同时发起 this.maxBatchSize 个请求
+  - 保持结果顺序与输入一致
+- **Acceptance Criteria Addressed**: [AC-2, AC-3]
+- **Test Requirements**:
+  - `programmatic` TR-3.1: 并发数不超过 this.maxBatchSize
+  - `programmatic` TR-3.2: 翻译结果顺序正确
+- **Status**: 已完成
+
+## [x] Task 4: 集成测试
+- **Priority**: P1
+- **Depends On**: Task 3
+- **Description**: 
+  - 完整测试 translateAll 函数
+  - 验证所有功能正常工作
+- **Acceptance Criteria Addressed**: [AC-1, AC-2, AC-3]
+- **Test Requirements**:
+  - `programmatic` TR-4.1: 完整功能测试通过
+- **Status**: 已完成

package/bin/translatecsvfile.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/src/RunTranslateCSV.js")

package/dist/src/CmdExecutor.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CmdExecutor = void 0;
+const CsvAutoTranslator_1 = require("./CsvAutoTranslator");
 const CSVUtils_1 = require("./CSVUtils");
 const LiteralCollector_1 = require("./LiteralCollector");
 const command_line_args_1 = __importDefault(require("command-line-args"));
@@ -106,5 +107,50 @@ class CmdExecutor {
         await CSVUtils_1.CSVUtils.slimCsvWithLangs(incsv, outcsv, langs);
         console.log("slim csv with langs done.");
     }
+    static async runTranslateCsvWithCmdOptions() {
+        const optionDefinitions = [
+            { name: 'incsv', type: String },
+            { name: 'outcsv', type: String },
+            { name: 'fromLang', type: String },
+            { name: 'toLangs', type: String, multiple: true, defaultOption: true },
+            { name: 'apiKey', type: String },
+            { name: 'appId', type: String },
+        ];
+        const options = (0, command_line_args_1.default)(optionDefinitions);
+        let incsv = options.incsv;
+        let outcsv = options.outcsv;
+        let fromLang = options.fromLang ?? undefined;
+        let toLangs = options.toLangs ?? undefined;
+        let apiKey = options.apiKey;
+        let appId = options.appId;
+        console.log(`slim csv cmd options: `, incsv, outcsv, fromLang, toLangs);
+        let argv = process.argv;
+        if (incsv == null) {
+            console.error(`incsv missing:`, argv);
+            return;
+        }
+        if (outcsv == null) {
+            console.error(`outcsv missing:`, argv);
+            return;
+        }
+        if (fromLang == null) {
+            console.error(`fromLang missing:`, argv);
+            return;
+        }
+        if (toLangs != null && toLangs.length == 0) {
+            console.error(`toLangs is empty:`, argv);
+            return;
+        }
+        if (apiKey == null) {
+            console.error(`apiKey missing:`, argv);
+            return;
+        }
+        if (appId == null) {
+            console.error(`appId missing:`, argv);
+            return;
+        }
+        await CsvAutoTranslator_1.CsvAutoTranslator.translateCsvWithLangs(incsv, outcsv, fromLang, toLangs, apiKey, appId);
+        console.log("translate csv with cmd options done.");
+    }
 }
 exports.CmdExecutor = CmdExecutor;

package/dist/src/CsvAutoTranslator.js

@@ -0,0 +1,272 @@
+"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.CsvAutoTranslator = void 0;
+const crypto = __importStar(require("crypto"));
+const https = __importStar(require("https"));
+const CSVUtils_1 = require("./CSVUtils");
+class CsvAutoTranslator {
+    apiKey;
+    appId;
+    apiUrl = "https://api.niutrans.com/v2/text/translate/array";
+    maxBatchSize = 5;
+    MAX_BATCH_TEXT_COUNT = 50;
+    MAX_BATCH_JSON_SIZE = 4900;
+    constructor(apiKey, appId) {
+        this.apiKey = apiKey;
+        this.appId = appId;
+    }
+    generateAuthStr(params) {
+        const sortedKeys = Object.keys(params).sort();
+        const paramStr = sortedKeys
+            .filter(key => params[key] !== "" && params[key] !== undefined && params[key] !== null)
+            .map(key => `${key}=${params[key]}`)
+            .join("&");
+        const fullStr = `apikey=${this.apiKey}&${paramStr}`;
+        return crypto.createHash("md5").update(fullStr).digest("hex");
+    }
+    async requestTranslate(texts, from, to) {
+        const timestamp = Date.now().toString();
+        const params = {
+            from: from,
+            to: to,
+            appId: this.appId,
+            timestamp: timestamp
+        };
+        const authStr = this.generateAuthStr(params);
+        const postData = JSON.stringify({
+            ...params,
+            srcText: texts,
+            authStr: authStr
+        });
+        const url = new URL(this.apiUrl);
+        const options = {
+            hostname: url.hostname,
+            port: 443,
+            path: url.pathname,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(postData)
+            }
+        };
+        return new Promise((resolve, reject) => {
+            const req = https.request(options, (res) => {
+                let data = "";
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", async () => {
+                    try {
+                        let ret = JSON.parse(data);
+                        await res.destroy();
+                        resolve(ret);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+            req.on("error", reject);
+            req.write(postData);
+            req.end();
+        });
+    }
+    async translateBatch(texts, from, to) {
+        const response = await this.requestTranslate(texts, from, to);
+        if (response.resultCode !== "200") {
+            throw new Error(`翻译失败: ${response.resultMsg}`);
+        }
+        return response.tgtList.map(item => item.tgtText || "");
+    }
+    estimateSingleTextJsonSize(text, isSingle) {
+        return Buffer.byteLength(JSON.stringify(text)) + (isSingle ? 0 : 1);
+    }
+    estimateJsonSize(texts) {
+        return Buffer.byteLength(JSON.stringify(texts));
+    }
+    smartBatch(texts, batches) {
+        const resultBatches = batches || [];
+        let startIndex = 0;
+        while (startIndex < texts.length) {
+            let endIndexMax = Math.min(startIndex + this.MAX_BATCH_TEXT_COUNT, texts.length);
+            let batchByteLength = 2;
+            let currentBatchCount = 0;
+            // let currentBatch = texts.slice(startIndex, endIndexMax);
+            for (let i = startIndex; i < endIndexMax; i++) {
+                const text = texts[i];
+                const textSize = Buffer.byteLength(text) + (i >= 1 ? 1 : 0);
+                currentBatchCount++;
+                batchByteLength += textSize;
+                if (batchByteLength + textSize > this.MAX_BATCH_JSON_SIZE) {
+                    break;
+                }
+            }
+            let endIndex = startIndex + currentBatchCount;
+            let currentBatch = texts.slice(startIndex, endIndex);
+            let currentSize = this.estimateJsonSize(currentBatch);
+            while (currentSize > this.MAX_BATCH_JSON_SIZE && currentBatch.length > 0) {
+                endIndex--;
+                let endText = texts[endIndex];
+                let endTextSize = this.estimateSingleTextJsonSize(endText, endIndex > startIndex + 1);
+                currentSize -= endTextSize;
+                currentBatch.pop();
+            }
+            if (currentBatch.length == 0 && startIndex < endIndexMax) {
+                console.error(`无法将文本分成合适的批次, 存在过长的文本, 起始索引: ${startIndex}, 结束索引: ${endIndex}`);
+                currentBatch = [''];
+                endIndex = startIndex + 1;
+            }
+            resultBatches.push(currentBatch);
+            startIndex = endIndex;
+        }
+        return resultBatches;
+    }
+    async translateAll(texts, from, to) {
+        const batches = this.smartBatch(texts);
+        const results = new Array(batches.length);
+        const concurrencyLimit = this.maxBatchSize;
+        let index = 0;
+        let batchCount = 0;
+        const processBatch = async () => {
+            while (index < batches.length) {
+                const batchIndex = index++;
+                const batch = batches[batchIndex];
+                batchCount++;
+                console.log(`batchCount++: ${batchCount}`);
+                const batchResults = await this.translateBatch(batch, from, to);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                batchCount--;
+                console.log(`batchCount--: ${batchCount}`);
+                results[batchIndex] = batchResults;
+            }
+        };
+        const workers = [];
+        for (let i = 0; i < concurrencyLimit && i < batches.length; i++) {
+            workers.push(processBatch());
+        }
+        await Promise.all(workers);
+        // await processBatch()
+        return results.flat();
+    }
+    langMap = new Map([
+        ["zh_cn", "zh"],
+        ["zh_hk", "cht"],
+        ["en_us", "en"],
+    ]);
+    async translateCsvRows(rows, fromLang, toLangs) {
+        if (rows.length === 0) {
+            console.log("CSV文件为空");
+            return 0;
+        }
+        let header = rows[0];
+        let fromLangIndex = header.indexOf(fromLang);
+        if (fromLangIndex === -1) {
+            console.error(`未找到 ${fromLang} 列`);
+            return 0;
+        }
+        if (!this.langMap.has(fromLang)) {
+            console.error(`未找到 ${fromLang} 的目标语言`);
+            return 0;
+        }
+        let fromLang2 = this.langMap.get(fromLang);
+        if (fromLang2 == null) {
+            console.error(`未找到 ${fromLang} 的目标语言`);
+            return 0;
+        }
+        const needTranslateIndices = [];
+        const needTranslateTexts = [];
+        for (let i = 1; i < rows.length; i++) {
+            const row = rows[i];
+            if (!row[0] || row[0].trim() === "") {
+                continue;
+            }
+            if (row[fromLangIndex] && row[fromLangIndex].trim() !== "") {
+                continue;
+            }
+            needTranslateIndices.push(i);
+            let text = row[fromLangIndex];
+            if (text == null || text == "") {
+                text = row[0];
+            }
+            needTranslateTexts.push(text);
+        }
+        if (needTranslateTexts.length === 0) {
+            console.log("没有需要翻译的内容");
+            return 0;
+        }
+        console.log(`开始翻译 ${needTranslateTexts.length} 条内容...`);
+        for (let curLangIndex = 0; curLangIndex < header.length; curLangIndex++) {
+            let lang = header[curLangIndex];
+            lang = lang.trim().toLowerCase();
+            if (lang == "key") {
+                continue;
+            }
+            if (toLangs != undefined && !toLangs.includes(lang)) {
+                continue;
+            }
+            if (lang != fromLang && this.langMap.has(lang)) {
+                const toLang = this.langMap.get(lang);
+                if (toLang == null) {
+                    console.error(`未找到 ${lang} 的目标语言`);
+                    continue;
+                }
+                const translations = await this.translateAll(needTranslateTexts, fromLang2, toLang);
+                for (let j = 0; j < needTranslateIndices.length; j++) {
+                    const rowIndex = needTranslateIndices[j];
+                    while (rows[rowIndex].length < header.length) {
+                        rows[rowIndex].push("");
+                    }
+                    rows[rowIndex][curLangIndex] = translations[j];
+                }
+            }
+        }
+        return needTranslateTexts.length;
+    }
+    async translateCsv(filePath, outFilePath, fromLang = "auto", toLangs) {
+        const csvUtils = new CSVUtils_1.CSVUtils(filePath);
+        const rows = await csvUtils.parseCsv();
+        const translatedCount = await this.translateCsvRows(rows, fromLang, toLangs);
+        if (translatedCount > 0) {
+            await CSVUtils_1.CSVUtils.writeCsv(outFilePath, rows);
+            console.log(`翻译完成，已更新 ${translatedCount} 条内容到 ${outFilePath}`);
+        }
+    }
+    static async translateCsvWithLangs(filePath, outFilePath, fromLang, langs, apiKey, appId) {
+        const translator = new CsvAutoTranslator(apiKey, appId);
+        await translator.translateCsv(filePath, outFilePath, fromLang, langs);
+    }
+}
+exports.CsvAutoTranslator = CsvAutoTranslator;

package/dist/src/RunTranslateCSV.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CmdExecutor_1 = require("./CmdExecutor");
+CmdExecutor_1.CmdExecutor.runTranslateCsvWithCmdOptions();