td-web-cli 0.1.0

package/dist/modules/i18n/excel2json/index.js

@@ -0,0 +1,302 @@
+import { input } from '@inquirer/prompts';
+import XLSX from 'xlsx';
+import fs from 'fs';
+import path from 'path';
+import { getTimestamp, logger, loggerError, normalizeError, languageToolCheck, getLanguageTool, } from '../../../utils/index.js';
+/**
+ * 读取并解析配置文件
+ * @param configPath 配置文件路径
+ * @returns I18nConfig 配置对象
+ * @throws 配置文件不存在或格式错误时抛出异常
+ */
+function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`配置文件不存在：${configPath}`);
+    }
+    const content = fs.readFileSync(configPath, { encoding: 'utf-8' });
+    const json = JSON.parse(content);
+    if (!json.i18n) {
+        throw new Error('配置文件格式错误，缺少i18n');
+    }
+    if (!json.i18n.defaultKey) {
+        throw new Error('配置文件格式错误，缺少i18n.defaultKey');
+    }
+    if (!json.i18n.langs) {
+        throw new Error('配置文件格式错误，缺少i18n.langs');
+    }
+    if (!json.i18n.longCodes) {
+        throw new Error('配置文件格式错误，缺少i18n.longCodes');
+    }
+    return json.i18n;
+}
+/**
+ * 匹配excel表头列名对应的语言key，支持大小写不敏感匹配
+ * 先匹配语言key本身，再匹配语言名称数组（包含关系）
+ * @param colName 表头列名
+ * @param langs 语言映射
+ * @returns 匹配到的语言key，未匹配返回null
+ */
+function matchLangKey(colName, langs) {
+    if (!colName)
+        return null;
+    const colNameLower = colName.toLowerCase();
+    // 先尝试匹配语言key
+    for (const langKey of Object.keys(langs)) {
+        if (langKey.toLowerCase() === colNameLower) {
+            return langKey;
+        }
+    }
+    // 再尝试匹配语言名称（包含关系）
+    for (const [langKey, names] of Object.entries(langs)) {
+        if (names.some((name) => name && colNameLower.includes(name.toLowerCase()))) {
+            return langKey;
+        }
+    }
+    return null;
+}
+/**
+ * 去除字符串首尾的单引号或双引号
+ * @param str 输入字符串
+ * @returns 去除引号后的字符串
+ */
+function trimQuotes(str) {
+    if ((str.startsWith('"') && str.endsWith('"')) ||
+        (str.startsWith("'") && str.endsWith("'"))) {
+        return str.slice(1, -1);
+    }
+    return str;
+}
+/**
+ * 批量检测词条文本，返回所有检测结果
+ * @param texts 词条数组
+ * @param language 语言代码
+ * @returns 检测结果数组，顺序对应输入texts
+ *
+ * 说明：
+ * 这里将所有词条用换行符拼接成一个字符串，一次性调用语言检测接口，
+ * 以减少请求次数和提升性能。
+ * 返回结果数组中只包含一个元素，即合并检测的结果。
+ */
+async function batchCheckTexts(texts, language) {
+    const results = [];
+    try {
+        // 将词条用换行符拼接，避免词条间干扰，推荐换行分隔
+        const joinedText = texts.join('\n');
+        const res = await languageToolCheck(joinedText, language);
+        results.push(res);
+    }
+    catch (error) {
+        loggerError(error, logger);
+        results.push(null);
+    }
+    return results;
+}
+/**
+ * excel转json功能主函数
+ * 读取用户输入的excel路径，解析内容，根据配置生成多语言json文件
+ * 并对配置文件中所有语言对应的词条进行语言检测
+ * @param program Commander命令行实例
+ */
+export async function excel2json(program) {
+    var _a;
+    // 配置文件默认路径
+    const configPath = path.join(process.cwd(), 'src/config/setting.json');
+    let i18nConfig;
+    // 加载配置文件
+    try {
+        logger.info(`开始加载配置文件：${configPath}`);
+        i18nConfig = loadConfig(configPath);
+        logger.info('配置文件加载成功');
+    }
+    catch (error) {
+        const msg = `读取配置文件失败：${normalizeError(error).stack}，程序已退出`;
+        logger.error(msg);
+        console.error('程序执行时发生异常，已记录日志，程序已退出');
+        process.exit(1);
+    }
+    // 尝试调用接口获取支持的语言列表，更新 longCodes
+    try {
+        logger.info('尝试获取在线支持的语言列表...');
+        const languageTools = await getLanguageTool();
+        logger.info(`成功获取语言列表，覆盖配置文件中的 longCodes`);
+        // 构建新的 longCodes 映射
+        const newLongCodes = {};
+        // 语言标识对应语言名称列表，方便匹配
+        const langNameToKey = {};
+        for (const [key, names] of Object.entries(i18nConfig.langs)) {
+            names.forEach((name) => {
+                langNameToKey[name.toLowerCase()] = key;
+            });
+        }
+        for (const lang of languageTools) {
+            // 尝试根据语言名称匹配配置中的语言key
+            const lowerName = lang.name.toLowerCase();
+            const matchedKey = langNameToKey[lowerName] ||
+                Object.keys(i18nConfig.langs).find((k) => k.toLowerCase() === lowerName);
+            if (matchedKey) {
+                newLongCodes[matchedKey] = lang.longCode;
+            }
+        }
+        // 替换旧的 longCodes，保留未匹配的旧值
+        i18nConfig.longCodes = { ...i18nConfig.longCodes, ...newLongCodes };
+    }
+    catch (error) {
+        logger.warn(`获取在线语言列表失败，使用本地配置 longCodes，错误：${normalizeError(error).stack}`);
+    }
+    // 交互式输入excel文件路径并校验
+    const answer = await input({
+        message: '请输入excel文件路径：',
+        validate: (value) => {
+            const cleaned = value.trim().replace(/^['"]|['"]$/g, '');
+            if (cleaned.length === 0)
+                return '路径不能为空';
+            if (!fs.existsSync(cleaned))
+                return '文件不存在，请输入有效路径';
+            if (!/\.(xls|xlsx)$/i.test(cleaned))
+                return '请输入有效的excel文件路径（.xls或.xlsx）';
+            return true;
+        },
+    });
+    // 规范化路径，支持相对路径转绝对路径，去除首尾引号
+    const excelPath = path.resolve(process.cwd(), answer.trim().replace(/^['"]|['"]$/g, ''));
+    try {
+        logger.info(`开始读取excel文件：${excelPath}`);
+        // 读取excel文件
+        const workbook = XLSX.readFile(excelPath);
+        const firstSheetName = workbook.SheetNames[0];
+        if (!firstSheetName) {
+            logger.error('excel文件没有任何工作表，程序已退出');
+            console.error('程序执行时发生异常，已记录日志，程序已退出');
+            process.exit(1);
+        }
+        // 读取第一个工作表的数据，按行读取，header=1表示返回二维数组
+        const sheet = workbook.Sheets[firstSheetName];
+        const rows = XLSX.utils.sheet_to_json(sheet, { header: 1 });
+        if (rows.length < 2) {
+            logger.error('工作表数据不足，至少需要两行（表头+数据），程序已退出');
+            console.error('程序执行时发生异常，已记录日志，程序已退出');
+            process.exit(1);
+        }
+        logger.info('开始解析表头');
+        // 处理表头行，去除空格，转成字符串
+        const headerRow = rows[0].map((cell) => (cell ? String(cell).trim() : ''));
+        // 根据表头匹配语言列，建立列索引到语言key的映射
+        const colIndexToLangKey = {};
+        headerRow.forEach((colName, idx) => {
+            const langKey = matchLangKey(colName, i18nConfig.langs);
+            if (langKey) {
+                colIndexToLangKey[idx] = langKey;
+            }
+        });
+        // 获取默认语言列索引
+        const defaultLang = i18nConfig.defaultKey;
+        const defaultColIndex = (_a = Object.entries(colIndexToLangKey).find(([, langKey]) => langKey === defaultLang)) === null || _a === void 0 ? void 0 : _a[0];
+        if (defaultColIndex === undefined) {
+            logger.error(`找不到默认语言列：${defaultLang}，程序已退出`);
+            console.error('程序执行时发生异常，已记录日志，程序已退出');
+            process.exit(1);
+        }
+        const defaultColNum = Number(defaultColIndex);
+        // 初始化所有语言词条对象（包括默认语言）
+        const langTranslations = {};
+        Object.values(colIndexToLangKey).forEach((langKey) => {
+            langTranslations[langKey] = {};
+        });
+        logger.info('开始解析数据行');
+        // 遍历数据行，提取所有语言词条
+        // key统一用默认语言列的值，其他语言对应的列为翻译内容
+        const langKeysMap = {}; // 语言key => 词条数组
+        Object.keys(langTranslations).forEach((langKey) => {
+            langKeysMap[langKey] = [];
+        });
+        for (let i = 1; i < rows.length; i++) {
+            const row = rows[i];
+            const keyCell = row[defaultColNum];
+            if (keyCell === undefined || keyCell === null || keyCell === '')
+                continue;
+            let key = String(keyCell).trim();
+            key = trimQuotes(key); // 去除引号
+            // 跳过空key，避免写入无效数据
+            if (key.length === 0)
+                continue;
+            // 默认语言的词条即key本身
+            langTranslations[defaultLang][key] = key;
+            langKeysMap[defaultLang].push(key);
+            // 其他语言词条
+            for (const [colIdxStr, langKey] of Object.entries(colIndexToLangKey)) {
+                const colIdx = Number(colIdxStr);
+                if (langKey === defaultLang)
+                    continue;
+                const valCell = row[colIdx];
+                if (valCell !== undefined && valCell !== null && valCell !== '') {
+                    const valStr = String(valCell);
+                    langTranslations[langKey][key] = valStr;
+                    langKeysMap[langKey].push(valStr);
+                }
+            }
+        }
+        // 对所有语言词条批量进行语言检测（包括默认语言）
+        for (const [langKey, texts] of Object.entries(langKeysMap)) {
+            const longCode = i18nConfig.longCodes[langKey];
+            if (!longCode) {
+                logger.warn(`语言(${langKey})未配置 longCode，跳过检测`);
+                continue;
+            }
+            if (texts.length === 0) {
+                logger.info(`语言(${langKey})无词条，跳过检测`);
+                continue;
+            }
+            logger.info(`开始对语言(${langKey})词条进行语言检测，词条数量：${texts.length}`);
+            const checkResults = await batchCheckTexts(texts, longCode);
+            if (!checkResults || checkResults.length === 0 || !checkResults[0]) {
+                logger.error(`语言(${langKey})词条检测失败`);
+                continue;
+            }
+            const result = checkResults[0];
+            if (result.matches.length === 0) {
+                logger.info(`语言(${langKey})词条检测无错误`);
+            }
+            else {
+                logger.info(`语言(${langKey})词条检测发现问题，词条数量: ${result.matches.length}`);
+                for (const match of result.matches) {
+                    logger.info(`- 错误: ${match.message}\n  出错句子: ${match.sentence}\n  建议替换: ${match.replacements
+                        .map((r) => r.value)
+                        .join(', ')}`);
+                }
+            }
+        }
+        // 输出目录：excel文件所在目录下的“lang_时间戳”文件夹
+        const excelDir = path.dirname(excelPath);
+        const timestamp = getTimestamp();
+        const outputRoot = path.join(excelDir, `lang_${timestamp}`);
+        if (!fs.existsSync(outputRoot)) {
+            fs.mkdirSync(outputRoot, { recursive: true });
+        }
+        logger.info(`开始生成语言文件，输出目录：${outputRoot}`);
+        // 按语言生成对应的json文件，默认语言的key=value不生成文件
+        for (const [langKey, translations] of Object.entries(langTranslations)) {
+            if (Object.keys(translations).length === 0)
+                continue;
+            if (langKey === defaultLang) {
+                logger.info(`跳过默认语言(${langKey})的json文件生成`);
+                continue; // 跳过默认语言文件生成
+            }
+            const langDir = path.join(outputRoot, langKey);
+            if (!fs.existsSync(langDir)) {
+                fs.mkdirSync(langDir, { recursive: true });
+            }
+            const filePath = path.join(langDir, 'translate.json');
+            fs.writeFileSync(filePath, JSON.stringify(translations, null, 2), {
+                encoding: 'utf-8',
+            });
+            logger.info(`已生成语言文件：${filePath}`);
+        }
+        logger.info('全部转换完成', true);
+    }
+    catch (error) {
+        // 记录错误日志，方便排查
+        loggerError(error, logger);
+        console.error('程序执行时发生异常，已记录日志，程序已退出');
+        process.exit(1);
+    }
+}

package/dist/modules/i18n/extractEntry/index.js

@@ -0,0 +1,3 @@
+export function run() {
+    console.log('提取词条');
+}

package/dist/modules/i18n/index.js

@@ -0,0 +1,71 @@
+import { select, Separator } from '@inquirer/prompts';
+import { excel2json } from './excel2json/index.js';
+import { logger, loggerError } from '../../utils/index.js';
+/**
+ * 国际化模块主入口
+ * 提供多个国际化相关功能的交互式选择
+ * @param program Commander命令行实例，用于传递参数和配置
+ */
+export async function i18n(program) {
+    try {
+        logger.info('国际化模块启动，等待用户选择功能');
+        // 定义可用功能选项
+        const moduleChoices = [
+            {
+                name: '提取词条',
+                value: 'extractEntry',
+                description: '从所给路径中提取词条信息',
+            },
+            {
+                name: 'json转excel',
+                value: 'json2excel',
+                description: '将json格式的词条信息转换为excel表格',
+            },
+            {
+                name: 'excel转json',
+                value: 'excel2json',
+                description: '将excel表格转换为json格式的词条信息',
+            },
+            {
+                name: 'json合并',
+                value: 'jsonMerge',
+                description: '合并多个json格式的词条信息文件',
+            },
+        ];
+        // 交互式选择需要执行的功能
+        const answer = await select({
+            message: '请选择要执行的功能：',
+            choices: [
+                ...moduleChoices,
+                new Separator(), // 分割线，方便未来扩展更多功能
+            ],
+            default: 'extractEntry', // 默认选项
+            pageSize: 10, // 最大显示选项数
+            loop: true, // 是否循环滚动选项
+        });
+        // 查找选择功能的名称，方便日志输出
+        const selectedModule = moduleChoices.find((item) => item.value === answer);
+        if (!selectedModule) {
+            logger.warn('未选择有效功能，程序已退出');
+            process.exit(0);
+        }
+        logger.info(`用户选择功能：${selectedModule.name}`);
+        // 根据选择执行对应功能
+        switch (answer) {
+            case 'excel2json':
+                logger.info(`${selectedModule.name}功能开始执行`);
+                await excel2json(program);
+                logger.info(`${selectedModule.name}功能执行完成`);
+                break;
+            default:
+                logger.warn(`${selectedModule.name}功能暂未实现，程序已退出`);
+                process.exit(0);
+        }
+    }
+    catch (error) {
+        // 记录错误日志，方便排查
+        loggerError(error, logger);
+        console.error('程序执行时发生异常，已记录日志，程序已退出');
+        process.exit(1);
+    }
+}

package/dist/modules/i18n/json2excel/index.js

@@ -0,0 +1,3 @@
+export function run() {
+    console.log('json转excel');
+}

package/dist/modules/i18n/jsonMerge/index.js

@@ -0,0 +1,3 @@
+export function run() {
+    console.log('json合并');
+}

package/dist/utils/index.js

@@ -0,0 +1,240 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getData, postData } from '../api/index.js';
+import api from '../api/interface.js';
+/**
+ * 获取当前时间戳字符串，格式为：YYYYMMDDHHMMSS
+ * 例如：20260123135500 表示 2026年01月23日 13点55分00秒
+ *
+ * @returns {string} 格式化后的时间戳字符串
+ */
+export function getTimestamp() {
+    const now = new Date();
+    /**
+     * 辅助函数：将数字转换为长度为2的字符串，不足时左侧补0
+     * @param n 需要格式化的数字
+     * @returns {string} 补零后的字符串
+     */
+    const pad = (n) => n.toString().padStart(2, '0');
+    const year = now.getFullYear(); // 获取四位年份
+    const month = pad(now.getMonth() + 1); // 获取月份（0-11），需+1，补零
+    const day = pad(now.getDate()); // 获取日期，补零
+    const hour = pad(now.getHours()); // 获取小时，补零
+    const minute = pad(now.getMinutes()); // 获取分钟，补零
+    const second = pad(now.getSeconds()); // 获取秒钟，补零
+    // 拼接成完整时间戳字符串
+    return `${year}${month}${day}${hour}${minute}${second}`;
+}
+/**
+ * 获取程序入口文件路径（兼容 ES Module）
+ * @returns 程序入口文件的绝对路径
+ */
+function getEntryFilePath() {
+    try {
+        // 当前模块文件路径
+        return fileURLToPath(import.meta.url);
+    }
+    catch {
+        // 兜底：使用 process.argv[1]
+        if (process.argv.length > 1) {
+            return path.resolve(process.cwd(), process.argv[1]);
+        }
+        // 最终兜底
+        return '';
+    }
+}
+/**
+ * 默认日志配置
+ * logsDir 默认设置为程序入口文件所在目录的上级目录的 logs 文件夹
+ */
+const defaultOptions = {
+    logsDir: '',
+    filenameFormatter: (date) => date.toISOString().slice(0, 10).replace(/-/g, '') + '.txt',
+    env: process.env.NODE_ENV || 'production',
+    entryFilePath: getEntryFilePath(),
+};
+/**
+ * 格式化日志内容，支持字符串或对象
+ * @param level 日志级别
+ * @param message 日志内容，字符串或对象
+ * @param date 当前时间
+ * @returns 格式化后的日志字符串
+ */
+function formatLogLine(level, message, date) {
+    const timeStr = date.toISOString();
+    let msgStr;
+    if (typeof message === 'string') {
+        msgStr = message;
+    }
+    else {
+        try {
+            msgStr = JSON.stringify(message, null, 2);
+        }
+        catch {
+            msgStr = String(message);
+        }
+    }
+    return `[${timeStr}] [${level}] ${msgStr}\n`;
+}
+/**
+ * 统一日志处理类
+ * 支持写入日志文件和控制台打印
+ */
+export class Logger {
+    /**
+     * 构造函数，初始化日志配置
+     * @param options 配置项，可选
+     */
+    constructor(options) {
+        var _a, _b;
+        const opts = { ...defaultOptions, ...options };
+        // 如果未传 logsDir，则默认设置为入口文件所在目录的上级目录的 logs 文件夹
+        this.logsDir =
+            opts.logsDir ||
+                path.resolve(path.dirname(opts.entryFilePath), '..', 'logs');
+        this.filenameFormatter =
+            (_a = opts.filenameFormatter) !== null && _a !== void 0 ? _a : defaultOptions.filenameFormatter;
+        this.env = (_b = opts.env) !== null && _b !== void 0 ? _b : defaultOptions.env;
+    }
+    /**
+     * 写日志主函数
+     * @param level 日志级别
+     * @param message 日志内容，支持字符串或对象
+     * @param printConsole 是否打印到控制台，默认 false
+     */
+    log(level, message, printConsole = false) {
+        const now = new Date();
+        const logLine = formatLogLine(level, message, now);
+        // 根据调用时是否指定打印控制台，决定是否打印
+        if (printConsole) {
+            switch (level) {
+                case 'INFO':
+                    console.info(logLine.trim());
+                    break;
+                case 'WARN':
+                    console.warn(logLine.trim());
+                    break;
+                case 'ERROR':
+                    console.error(logLine.trim());
+                    break;
+            }
+        }
+        try {
+            // 确保日志目录存在
+            if (!fs.existsSync(this.logsDir)) {
+                fs.mkdirSync(this.logsDir, { recursive: true });
+            }
+            const filename = this.filenameFormatter(now);
+            const logFilePath = path.join(this.logsDir, filename);
+            // 追加写入日志文件
+            fs.appendFileSync(logFilePath, logLine, { encoding: 'utf8' });
+        }
+        catch (error) {
+            // 仅在开发环境打印写日志异常堆栈，生产环境静默失败，避免影响主程序
+            if (this.env === 'development') {
+                console.error('日志写入异常：', normalizeError(error).stack);
+            }
+        }
+    }
+    /**
+     * 记录信息级别日志
+     * @param message 日志内容
+     * @param printConsole 是否打印到控制台，默认 false
+     */
+    info(message, printConsole = false) {
+        this.log('INFO', message, printConsole);
+    }
+    /**
+     * 记录警告级别日志
+     * @param message 日志内容
+     * @param printConsole 是否打印到控制台，默认 false
+     */
+    warn(message, printConsole = false) {
+        this.log('WARN', message, printConsole);
+    }
+    /**
+     * 记录错误级别日志
+     * @param message 日志内容
+     * @param printConsole 是否打印到控制台，默认 false
+     */
+    error(message, printConsole = false) {
+        this.log('ERROR', message, printConsole);
+    }
+}
+/**
+ * 默认导出单例 logger，方便直接使用
+ * 默认不打印控制台日志
+ */
+export const logger = new Logger({
+    env: process.env.NODE_ENV || 'development',
+});
+/**
+ * 通用错误日志记录函数
+ * @param error 捕获的错误对象
+ * @param logger 日志对象，需包含 error 方法
+ * @param prefix 日志前缀，方便区分来源，默认值为 '程序执行时发生错误'
+ * @param printConsole 是否打印错误日志到控制台，默认 false
+ */
+export function loggerError(error, logger, prefix = '程序执行时发生错误', printConsole = false) {
+    logger.error(`${prefix}：${normalizeError(error).stack}`, printConsole);
+}
+/**
+ * 将任意错误对象规范化为 Error 类型。
+ * @param err - 可能是 Error、字符串或其他任意类型
+ * @returns 标准的 Error 对象
+ */
+export const normalizeError = (err) => {
+    if (err instanceof Error) {
+        // 已经是 Error 类型，直接返回
+        return err;
+    }
+    else if (typeof err === 'string') {
+        // 如果是字符串，创建新的 Error
+        return new Error(err);
+    }
+    else {
+        // 其他情况，返回通用错误
+        return new Error('未知错误');
+    }
+};
+/**
+ * 获取支持的语言列表
+ * 调用语言工具接口，返回所有支持的语言信息数组
+ * @returns Promise<LanguageTool> 返回语言列表的 Promise
+ * @throws 接口请求失败时抛出错误，错误信息包含接口地址和异常堆栈
+ */
+export async function getLanguageTool() {
+    const url = api.LANGUAGE_TOOL_V2_LANGUAGES;
+    try {
+        const res = await getData(url);
+        return res;
+    }
+    catch (error) {
+        // 捕获异常并包装错误信息，包含接口地址和堆栈信息
+        throw new Error(`${url}接口报错：${normalizeError(error).stack}`);
+    }
+}
+/**
+ * 调用语言检测接口，检测文本中的语言错误
+ * @param text 待检测文本
+ * @param language 语言代码，默认 'en-US'
+ * @returns Promise<CheckResult> 返回检测结果的 Promise
+ * @throws 接口请求失败时抛出错误，错误信息包含接口地址和异常堆栈
+ */
+export async function languageToolCheck(text, language = 'en-US') {
+    const url = api.LANGUAGE_TOOL_V2_CHECK;
+    const params = new URLSearchParams();
+    params.append('text', text);
+    params.append('language', language);
+    try {
+        const res = await postData(url, params.toString(), {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        });
+        return res;
+    }
+    catch (error) {
+        // 捕获异常并包装错误信息，包含接口地址和堆栈信息
+        throw new Error(`${url}接口报错：${normalizeError(error).stack}`);
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "td-web-cli",
+  "version": "0.1.0",
+  "description": "A CLI tool for efficiency",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "td-web-cli": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.{js,ts,tsx,json,md}\""
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "axios": "^1.13.3",
+    "commander": "^14.0.2",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@types/commander": "^2.12.0",
+    "@types/node": "^25.0.10",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3"
+  }
+}