Translating Project

node_modules

# Agent Domain Glossary
# 智能体领域术语表

domain = "agent"
description = "智能体领域的术语表"
when_to_use = "当翻译内容涉及 AI Agent、智能体、Skill、技能、Workflow、工作流、LLM、大语言模型、Prompt、提示词、 Claude、OpenAI 等人工智能相关概念时使用"

[[rules]]
term = "agent"
action = "translate"
translation = "智能体"
reason = "agent 统一翻译为智能体"

[[rules]]
term = "AI Agent"
action = "translate"
translation = "AI 智能体"
reason = "AI Agent 翻译为 AI 智能体"

[[rules]]
term = "skill"
action = "keep"
translation = "skill"
reason = "在智能体领域，skill 是核心概念，保留英文术语"

[[rules]]
term = "workflow"
action = "translate"
translation = "工作流"
reason = "workflow 翻译为工作流"

[[rules]]
term = "LLM"
action = "translate"
translation = "大语言模型"
reason = "LLM 翻译为大语言模型"

[[rules]]
term = "prompt"
action = "translate"
translation = "提示词"
reason = "prompt 翻译为提示词"

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Glossary Schema",
  "description": "术语表结构定义，支持 CSV 和 TOML 两种格式",
  "definitions": {
    "rule": {
      "type": "object",
      "properties": {
        "term": {
          "type": "string",
          "description": "术语原文（必填）"
        },
        "action": {
          "type": "string",
          "enum": ["keep", "translate"],
          "description": "规则类型（必填）：keep 保留原文，translate 强制翻译"
        },
        "translation": {
          "type": "string",
          "description": "翻译结果（action=translate 时必填，action=keep 时可选）"
        },
        "reason": {
          "type": "string",
          "description": "翻译说明（选填）"
        }
      },
      "required": ["term", "action"],
      "if": {
        "properties": {
          "action": {
            "const": "translate"
          }
        },
        "required": ["action"]
      },
      "then": {
        "required": ["translation"]
      }
    }
  },
  "allOf": [
    {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "format": {
              "const": "csv",
              "description": "CSV 格式术语表"
            },
            "columns": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": ["term", "action", "translation", "reason"]
              },
              "description": "CSV 列顺序：term, action, translation, reason"
            },
            "requiredColumns": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "必填列",
              "default": ["term", "action", "translation"]
            },
            "rules": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/rule"
              },
              "minItems": 1,
              "description": "术语规则列表"
            }
          },
          "required": ["format", "columns", "rules"]
        },
        {
          "type": "object",
          "properties": {
            "format": {
              "const": "toml",
              "description": "TOML 格式术语表"
            },
            "domain": {
              "type": "string",
              "description": "术语表所属领域"
            },
            "description": {
              "type": "string",
              "description": "术语表描述"
            },
            "rules": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/rule"
              },
              "minItems": 1,
              "description": "术语规则列表"
            }
          },
          "required": ["format", "domain", "rules"]
        }
      ]
    }
  ]
}

{
  "targetLanguage": "中文",
  "targetBranch": "upstream/master",
  "taskTrackingFile": ".todo/project-translation-task.md",
  "fileFilters": {
    "ignoreGitignore": true,
    "supportedExtensions": [
      ".md",
      ".py",
      ".js",
      ".ts",
      ".tsx",
      ".jsx",
      ".java",
      ".cpp",
      ".c",
      ".h",
      ".hpp",
      ".go",
      ".rs",
      ".kt",
      ".swift",
      ".rb",
      ".php",
      ".scala",
      ".cs",
      ".vue"
    ],
    "excludeFiles": [
      "LICENSE",
      "COPYRIGHT",
      "COPYING",
      "LICENSE.md",
      "LICENSE.txt",
      "CHANGELOG.md",
      "CONTRIBUTING.md"
    ],
    "excludeDirs": [
      ".git",
      ".idea",
      "node_modules",
      "dist",
      ".vscode"
    ]
  },
  "translation": {
    "priority": [
      "README.md",
      "*.md",
      "docs/",
      "src/",
      "lib/",
      "app/"
    ],
    "previewLines": 20
  }
}

{
  "name": "translating-project",
  "version": "1.1.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "translating-project",
      "version": "1.1.0",
      "dependencies": {
        "franc": "^6.2.0"
      },
      "bin": {
        "tp": "tools/tp.js"
      },
      "engines": {
        "node": ">=14.0.0"
      }
    },
    "node_modules/collapse-white-space": {
      "version": "2.1.0",
      "resolved": "https://registry.npmmirror.com/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
      "integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
      "license": "MIT",
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/wooorm"
      }
    },
    "node_modules/franc": {
      "version": "6.2.0",
      "resolved": "https://registry.npmmirror.com/franc/-/franc-6.2.0.tgz",
      "integrity": "sha512-rcAewP7PSHvjq7Kgd7dhj82zE071kX5B4W1M4ewYMf/P+i6YsDQmj62Xz3VQm9zyUzUXwhIde/wHLGCMrM+yGg==",
      "license": "MIT",
      "dependencies": {
        "trigram-utils": "^2.0.0"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/wooorm"
      }
    },
    "node_modules/n-gram": {
      "version": "2.0.2",
      "resolved": "https://registry.npmmirror.com/n-gram/-/n-gram-2.0.2.tgz",
      "integrity": "sha512-S24aGsn+HLBxUGVAUFOwGpKs7LBcG4RudKU//eWzt/mQ97/NMKQxDWHyHx63UNWk/OOdihgmzoETn1tf5nQDzQ==",
      "license": "MIT",
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/wooorm"
      }
    },
    "node_modules/trigram-utils": {
      "version": "2.0.1",
      "resolved": "https://registry.npmmirror.com/trigram-utils/-/trigram-utils-2.0.1.tgz",
      "integrity": "sha512-nfWIXHEaB+HdyslAfMxSqWKDdmqY9I32jS7GnqpdWQnLH89r6A5sdk3fDVYqGAZ0CrT8ovAFSAo6HRiWcWNIGQ==",
      "license": "MIT",
      "dependencies": {
        "collapse-white-space": "^2.0.0",
        "n-gram": "^2.0.0"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/wooorm"
      }
    }
  }
}

{
  "name": "translating-project",
  "version": "1.1.0",
  "description": "项目翻译助手（tp），批量翻译项目文档和代码文件为中文",
  "bin": {
    "tp": "./tools/tp.js"
  },
  "scripts": {
    "scan": "node tools/tp.js scan",
    "translate": "node tools/tp.js translate",
    "update": "node tools/tp.js update"
  },
  "engines": {
    "node": ">=14.0.0"
  },
  "keywords": [
    "translation",
    "i18n",
    "localization",
    "claude-skill"
  ],
  "dependencies": {
    "franc": "^6.2.0"
  }
}

const FileScanner = require('./tools/lib/scanner');
const path = require('path');
const fs = require('fs');

// 创建一个临时测试目录
const testDir = '/tmp/test_scan_exclude_' + Date.now();
fs.mkdirSync(testDir, { recursive: true });
fs.mkdirSync(path.join(testDir, 'subdir'), { recursive: true });

// 创建一些测试文件
fs.writeFileSync(path.join(testDir, 'README.md'), '# Test');
fs.writeFileSync(path.join(testDir, 'LICENSE'), 'MIT');  // 应该被排除
fs.writeFileSync(path.join(testDir, 'normal.js'), 'const x = 1;');
fs.writeFileSync(path.join(testDir, 'subdir', 'nested.md'), '# Nested');

console.log('测试目录结构:');
console.log(fs.readdirSync(testDir, { recursive: true }));

// 配置：排除 LICENSE
const config = {
  fileFilters: {
    supportedExtensions: ['.md', '.js'],
    excludeFiles: ['LICENSE', 'COPYRIGHT'],  // 应该排除 LICENSE
    excludeDirs: ['node_modules', '.git']
  },
  translation: {
    langdetectMinLength: 3
  }
};

console.log('\n配置 excludeFiles:', config.fileFilters.excludeFiles);

async function test() {
  const scanner = new FileScanner(config);
  const files = await scanner.scan(testDir);
  
  console.log('\n扫描结果:');
  files.forEach(f => console.log(' -', path.basename(f.path)));
  
  // 验证 LICENSE 是否被排除
  const hasLicense = files.some(f => path.basename(f.path) === 'LICENSE');
  console.log('\n验证:');
  console.log('LICENSE 是否被排除:', !hasLicense);
  
  if (hasLicense) {
    console.log('✗ BUG: LICENSE 应该被排除但却被扫描了');
  } else {
    console.log('✓ 正确: LICENSE 已被排除');
  }
  
  // 清理
  fs.rmSync(testDir, { recursive: true });
}

test().catch(console.error);

#!/usr/bin/env node

/**
 * config 命令 - 配置管理
 * 
 * 用法: tp config <subcommand> [options]
 */

const fs = require('fs');
const path = require('path');
const os = require('os');
const { getGitRoot } = require('./lib/git');

const SUBCOMMANDS = {
  get,
  set,
  list,
};

function parseArgs(args) {
  const options = {
    subcommand: null,
    args: [],
    workingDir: process.cwd(),
    source: null, // 'project' | 'global' | 'default' | null
  };
  
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    
    if (arg === '--help' || arg === '-h') {
      showHelp();
      process.exit(0);
    } else if (arg === '--working-dir' || arg === '-w') {
      options.workingDir = args[++i];
    } else if (arg === '--global' || arg === '-g') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'global';
    } else if (arg === '--project' || arg === '-p') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'project';
    } else if (arg === '--default' || arg === '-d') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'default';
    } else if (!options.subcommand && !arg.startsWith('-')) {
      options.subcommand = arg;
    } else {
      options.args.push(arg);
    }
  }
  
  return options;
}

function showHelp() {
  console.log(`
配置管理

用法: tp config <subcommand> -w <path> [options]

子命令:
  get [key]            获取配置值
  set <key> <value>    设置配置值
  list                 列出配置

必填选项:
  -w, --working-dir <path>  指定工作目录（将自动定位到 Git 仓库根目录）

可选选项（互斥，只能使用其一）：
  -p, --project        仅使用项目配置
  -g, --global         仅使用个人全局配置
  -d, --default        仅使用默认配置

说明:
- -w 指定工作目录后，会自动使用 git rev-parse --show-toplevel 获取仓库根目录
- 不指定 -p/-g/-d 时，按优先级合并：项目 > 个人 > 默认
- 指定 -p/-g/-d 时，仅使用对应层级的配置
- set 子命令不能配合 -d 使用（默认配置只读）

示例:
  tp config list -w ./my-project
  tp config get targetLanguage -w ./my-project -g
  tp config set targetLanguage "中文" -w ./my-project
`);
}

function getConfigPath(source, workingDir) {
  switch (source) {
    case 'default':
      return path.join(__dirname, '..', 'configs', 'setting.json');
    case 'global':
      return path.join(os.homedir(), '.tp', 'config.json');
    case 'project':
    default:
      return path.join(workingDir, '.tp', 'config.json');
  }
}

function readConfig(configPath) {
  if (!fs.existsSync(configPath)) {
    return {};
  }
  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
}

function writeConfig(configPath, config) {
  const dir = path.dirname(configPath);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
}

function loadConfig(source, workingDir) {
  // 如果指定了 source，只读取对应层级
  if (source) {
    const configPath = getConfigPath(source, workingDir);
    return {
      ...readConfig(configPath),
      _meta: { source }
    };
  }
  
  // 否则合并三层配置
  const defaultConfig = readConfig(getConfigPath('default', workingDir));
  const globalConfig = readConfig(getConfigPath('global', workingDir));
  const projectConfig = readConfig(getConfigPath('project', workingDir));
  
  return {
    ...defaultConfig,
    ...globalConfig,
    ...projectConfig,
    _meta: {
      project: Object.keys(projectConfig).length > 0,
      global: Object.keys(globalConfig).length > 0,
      default: Object.keys(defaultConfig).length > 0,
    }
  };
}

async function get(args, options) {
  const key = args[0];
  const config = loadConfig(options.source, options.workingDir);
  
  if (key) {
    const value = key.split('.').reduce((obj, k) => obj?.[k], config);
    console.log(value !== undefined ? value : '(未设置)');
  } else {
    const { _meta, ...rest } = config;
    console.log(JSON.stringify(rest, null, 2));
  }
}

async function set(args, options) {
  const [key, ...valueParts] = args;
  const value = valueParts.join(' ');
  
  if (!key || value === undefined) {
    throw new Error('请指定 key 和 value');
  }
  
  if (options.source === 'default') {
    throw new Error('不能修改默认配置，请使用 -p 或 -g');
  }
  
  // 默认写入项目配置，-g 时写入个人配置
  const targetSource = options.source === 'global' ? 'global' : 'project';
  const configPath = getConfigPath(targetSource, options.workingDir);
  const config = readConfig(configPath);
  
  // 支持嵌套 key
  const keys = key.split('.');
  let current = config;
  for (let i = 0; i < keys.length - 1; i++) {
    if (!current[keys[i]]) current[keys[i]] = {};
    current = current[keys[i]];
  }
  
  // 尝试解析为 JSON
  try {
    current[keys[keys.length - 1]] = JSON.parse(value);
  } catch {
    current[keys[keys.length - 1]] = value;
  }
  
  writeConfig(configPath, config);
  const configType = targetSource === 'global' ? '个人配置' : '项目配置';
  console.log(`${configType} 设置: ${key} = ${value}`);
}

async function list(args, options) {
  const config = loadConfig(options.source, options.workingDir);
  const { _meta, ...rest } = config;
  
  if (_meta.source) {
    console.log(`${_meta.source} 配置:`);
  } else {
    console.log('合并配置（项目 → 个人 → 默认）:');
  }
  
  console.log(JSON.stringify(rest, null, 2));
  
  if (!_meta.source) {
    console.log('\n配置来源:');
    console.log(`  项目配置: ${_meta.project ? '✓' : '✗'}`);
    console.log(`  个人配置: ${_meta.global ? '✓' : '✗'}`);
    console.log(`  默认配置: ${_meta.default ? '✓' : '✗'}`);
  }
}

async function command(args) {
  const options = parseArgs(args);
  
  if (!options.subcommand) {
    console.error('错误: 请指定子命令');
    showHelp();
    process.exit(1);
  }
  
  // 自动定位到 Git 仓库根目录
  const gitRoot = getGitRoot(options.workingDir);
  if (gitRoot) {
    options.workingDir = gitRoot;
  }
  
  const handler = SUBCOMMANDS[options.subcommand];
  if (!handler) {
    console.error(`错误: 未知子命令 "${options.subcommand}"`);
    showHelp();
    process.exit(1);
  }
  
  return await handler(options.args, options);
}

module.exports = command;

if (require.main === module) {
  command(process.argv.slice(2)).catch(error => {
    console.error(`错误: ${error.message}`);
    process.exit(1);
  });
}

#!/usr/bin/env node

/**
 * glossary 命令 - 术语表管理
 * 
 * 用法: tp glossary <subcommand> -w <path> [options]
 */

const fs = require('fs');
const path = require('path');
const os = require('os');
const { getGitRoot } = require('./lib/git');

const SUBCOMMANDS = {
  add,
  list,
  show,
  remove,
};

function parseArgs(args) {
  const options = {
    subcommand: null,
    args: [],
    workingDir: process.cwd(),
    source: null, // 'project' | 'global' | 'default' | null
  };
  
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    
    if (arg === '--help' || arg === '-h') {
      showHelp();
      process.exit(0);
    } else if (arg === '--working-dir' || arg === '-w') {
      options.workingDir = args[++i];
    } else if (arg === '--global' || arg === '-g') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'global';
    } else if (arg === '--project' || arg === '-p') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'project';
    } else if (arg === '--default' || arg === '-d') {
      if (options.source) throw new Error('选项 -p/-g/-d 互斥，只能使用其一');
      options.source = 'default';
    } else if (!options.subcommand && !arg.startsWith('-')) {
      options.subcommand = arg;
    } else {
      options.args.push(arg);
    }
  }
  
  return options;
}

function showHelp() {
  console.log(`
术语表管理

用法: tp glossary <subcommand> -w <path> [options]

子命令:
  add <file>           添加术语表文件
  list                 列出所有术语表
  show <name>          查看术语表内容
  remove <name>        删除术语表

必填选项:
  -w, --working-dir <path>  指定工作目录（将自动定位到 Git 仓库根目录）

可选选项（互斥，只能使用其一）：
  -p, --project        仅使用项目术语表
  -g, --global         仅使用个人全局术语表
  -d, --default        仅使用默认术语表

说明:
- -w 指定工作目录后，会自动使用 git rev-parse --show-toplevel 获取仓库根目录
- 不指定 -p/-g/-d 时，显示所有层级术语表
- 指定 -p/-g/-d 时，仅操作对应层级的术语表
- add/remove 不能配合 -d 使用（默认术语表只读）

示例:
  tp glossary list -w ./my-project
  tp glossary show agent -w ./my-project
  tp glossary add ./terms.csv -w ./my-project -g
`);
}

function getGlossaryDir(source, workingDir) {
  switch (source) {
    case 'default':
      return path.join(__dirname, '..', 'assets', 'glossary');
    case 'global':
      return path.join(os.homedir(), '.tp', 'glossary');
    case 'project':
    default:
      return path.join(workingDir, '.tp', 'glossary');
  }
}

function ensureGlossaryDir(dir) {
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
}

function getGlossaryFiles(dir) {
  if (!fs.existsSync(dir)) {
    return [];
  }
  return fs.readdirSync(dir)
    .filter(f => f.endsWith('.csv') || f.endsWith('.toml'))
    .sort();
}

/**
 * 加载合并后的术语表（三层合并）
 */
function loadMergedGlossaries(source, workingDir) {
  const defaultDir = path.join(__dirname, '..', 'assets', 'glossary');
  const globalDir = path.join(os.homedir(), '.tp', 'glossary');
  const projectDir = path.join(workingDir, '.tp', 'glossary');
  
  const result = {
    default: [],
    global: [],
    project: [],
    merged: {},
    _meta: {
      default: fs.existsSync(defaultDir),
      global: fs.existsSync(globalDir),
      project: fs.existsSync(projectDir),
    }
  };
  
  // 按优先级从低到高加载
  if (fs.existsSync(defaultDir)) {
    result.default = getGlossaryFiles(defaultDir).map(f => ({
      name: f.replace(/\.(csv|toml)$/i, ''),
      file: f,
      path: path.join(defaultDir, f),
      source: 'default'
    }));
  }
  
  if (fs.existsSync(globalDir)) {
    result.global = getGlossaryFiles(globalDir).map(f => ({
      name: f.replace(/\.(csv|toml)$/i, ''),
      file: f,
      path: path.join(globalDir, f),
      source: 'global'
    }));
  }
  
  if (fs.existsSync(projectDir)) {
    result.project = getGlossaryFiles(projectDir).map(f => ({
      name: f.replace(/\.(csv|toml)$/i, ''),
      file: f,
      path: path.join(projectDir, f),
      source: 'project'
    }));
  }
  
  // 构建合并索引（高优先级覆盖低优先级同名文件）
  [...result.default, ...result.global, ...result.project].forEach(g => {
    result.merged[g.name] = g;
  });
  
  return result;
}

/**
 * 添加术语表
 */
async function add(args, options) {
  const filePath = args[0];
  if (!filePath) {
    throw new Error('请指定术语表文件路径');
  }
  
  if (!fs.existsSync(filePath)) {
    throw new Error(`文件不存在: ${filePath}`);
  }
  
  const ext = path.extname(filePath).toLowerCase();
  if (!['.csv', '.toml'].includes(ext)) {
    throw new Error('只支持 CSV 或 TOML 格式');
  }
  
  if (options.source === 'default') {
    throw new Error('不能修改默认术语表，请使用 -p 或 -g');
  }
  
  // 默认写入项目术语表，-g 时写入个人术语表
  const targetSource = options.source === 'global' ? 'global' : 'project';
  const glossaryDir = getGlossaryDir(targetSource, options.workingDir);
  ensureGlossaryDir(glossaryDir);
  
  const fileName = path.basename(filePath);
  const destPath = path.join(glossaryDir, fileName);
  
  fs.copyFileSync(filePath, destPath);
  
  const sourceType = targetSource === 'global' ? '个人术语表' : '项目术语表';
  console.log(`添加术语表到 ${sourceType}: ${destPath}`);
}

/**
 * 列出术语表
 */
async function list(args, options) {
  const glossaries = loadMergedGlossaries(options.source, options.workingDir);
  
  // 如果指定了 source，仅显示对应层级
  if (options.source) {
    console.log(`${options.source} 术语表:`);
    const files = glossaries[options.source];
    if (files.length > 0) {
      files.forEach(g => console.log(`  - ${g.file}`));
    } else {
      console.log('  (无)');
    }
    return;
  }
  
  // 显示所有层级
  console.log('默认术语表:');
  if (glossaries.default.length > 0) {
    glossaries.default.forEach(g => console.log(`  - ${g.file}`));
  } else {
    console.log('  (无)');
  }
  
  console.log('\n个人术语表:');
  if (glossaries.global.length > 0) {
    glossaries.global.forEach(g => console.log(`  - ${g.file}`));
  } else {
    console.log('  (无)');
  }
  
  console.log('\n项目术语表:');
  if (glossaries.project.length > 0) {
    glossaries.project.forEach(g => console.log(`  - ${g.file}`));
  } else {
    console.log('  (无)');
  }
  
  console.log('\n实际生效的术语表（按优先级合并）:');
  const mergedNames = Object.keys(glossaries.merged);
  if (mergedNames.length > 0) {
    mergedNames.forEach(name => {
      const g = glossaries.merged[name];
      console.log(`  - ${name} (${g.source})`);
    });
  } else {
    console.log('  (无)');
  }
}

/**
 * 查看术语表
 */
async function show(args, options) {
  const name = args[0];
  if (!name) {
    throw new Error('请指定术语表名称');
  }
  
  // 如果指定了 source，直接从对应层级查找
  if (options.source) {
    const glossaryDir = getGlossaryDir(options.source, options.workingDir);
    const exts = ['.toml', '.csv'];
    let filePath = null;
    
    for (const ext of exts) {
      const tryPath = path.join(glossaryDir, name + ext);
      if (fs.existsSync(tryPath)) {
        filePath = tryPath;
        break;
      }
    }
    
    if (!filePath) {
      throw new Error(`${options.source} 术语表中不存在: ${name}`);
    }
    
    console.log(`来源: ${options.source} (${filePath})\n`);
    console.log(fs.readFileSync(filePath, 'utf8'));
    return;
  }
  
  // 按优先级查找
  const glossaries = loadMergedGlossaries(options.source, options.workingDir);
  const glossary = glossaries.merged[name];
  
  if (!glossary) {
    throw new Error(`术语表不存在: ${name}`);
  }
  
  console.log(`来源: ${glossary.source} (${glossary.path})\n`);
  console.log(fs.readFileSync(glossary.path, 'utf8'));
}

/**
 * 删除术语表
 */
async function remove(args, options) {
  const name = args[0];
  if (!name) {
    throw new Error('请指定术语表名称');
  }
  
  if (options.source === 'default') {
    throw new Error('不能删除默认术语表，请使用 -p 或 -g');
  }
  
  // 默认删除项目术语表，-g 时删除个人术语表
  const targetSource = options.source === 'global' ? 'global' : 'project';
  const glossaryDir = getGlossaryDir(targetSource, options.workingDir);
  
  const exts = ['.toml', '.csv'];
  let filePath = null;
  
  for (const ext of exts) {
    const tryPath = path.join(glossaryDir, name + ext);
    if (fs.existsSync(tryPath)) {
      filePath = tryPath;
      break;
    }
  }
  
  if (!filePath) {
    const sourceType = targetSource === 'global' ? '个人术语表' : '项目术语表';
    throw new Error(`${sourceType}中不存在: ${name}`);
  }
  
  fs.unlinkSync(filePath);
  const sourceType = targetSource === 'global' ? '个人术语表' : '项目术语表';
  console.log(`从 ${sourceType} 删除: ${filePath}`);
}

async function command(args) {
  const options = parseArgs(args);
  
  if (!options.subcommand) {
    console.error('错误: 请指定子命令');
    showHelp();
    process.exit(1);
  }
  
  // 自动定位到 Git 仓库根目录
  const gitRoot = getGitRoot(options.workingDir);
  if (gitRoot) {
    options.workingDir = gitRoot;
  }
  
  const handler = SUBCOMMANDS[options.subcommand];
  if (!handler) {
    console.error(`错误: 未知子命令 "${options.subcommand}"`);
    showHelp();
    process.exit(1);
  }
  
  return await handler(options.args, options);
}

module.exports = command;

if (require.main === module) {
  command(process.argv.slice(2)).catch(error => {
    console.error(`错误: ${error.message}`);
    process.exit(1);
  });
}

const fs = require('fs');
const path = require('path');
const os = require('os');

/**
 * 获取默认配置
 * @returns {Object} 默认配置对象
 */
function getDefaultConfig() {
  return {
    targetLanguage: "中文",
    taskTrackingFile: ".todo/tp-tasks.md",
    fileFilters: {
      ignoreGitignore: true,
      supportedExtensions: [
        ".md", ".py", ".js", ".ts", ".tsx", ".jsx", ".java", ".cpp", ".c", 
        ".h", ".hpp", ".go", ".rs", ".kt", ".swift", ".rb", ".php", 
        ".scala", ".cs", ".vue"
      ],
      excludeFiles: ["LICENSE", "COPYRIGHT", "COPYING"],
      excludeDirs: [
        "__pycache__", ".git", ".idea", "node_modules", "venv", "env", 
        "dist", "build", "target", ".vscode"
      ]
    },
    translation: {
      priority: ["README.md", "CONTRIBUTING.md", "CHANGELOG.md", "docs/", "src/", "lib/", "app/"],
      previewLines: 20
    }
  };
}

/**
 * 加载配置（支持多层级）
 * 优先级：项目配置 > 个人配置 > 默认配置
 * 
 * @param {string} projectPath - 项目路径
 * @returns {Object} 配置对象
 */
function loadConfig(projectPath) {
  const defaultConfig = getDefaultConfig();
  
  // 1. 加载个人配置 (~/.tp/config.json)
  const personalConfigPath = path.join(os.homedir(), '.tp', 'config.json');
  let personalConfig = {};
  if (fs.existsSync(personalConfigPath)) {
    try {
      const content = fs.readFileSync(personalConfigPath, 'utf-8');
      personalConfig = JSON.parse(content);
    } catch (error) {
      console.warn(`警告: 无法加载个人配置文件 ${personalConfigPath}: ${error.message}`);
    }
  }
  
  // 2. 加载项目配置 (<project>/.tp/config.json)
  let projectConfig = {};
  if (projectPath) {
    const projectConfigPath = path.join(projectPath, '.tp', 'config.json');
    if (fs.existsSync(projectConfigPath)) {
      try {
        const content = fs.readFileSync(projectConfigPath, 'utf-8');
        projectConfig = JSON.parse(content);
        projectConfig._source = 'project';
      } catch (error) {
        console.warn(`警告: 无法加载项目配置文件 ${projectConfigPath}: ${error.message}`);
      }
    }
  }
  
  // 3. 合并配置（项目 > 个人 > 默认）
  const mergedConfig = deepMerge(defaultConfig, personalConfig, projectConfig);
  
  // 记录配置来源
  if (!mergedConfig._source) {
    if (projectConfig._source) {
      mergedConfig._source = 'project';
    } else if (Object.keys(personalConfig).length > 0) {
      mergedConfig._source = 'personal';
    } else {
      mergedConfig._source = 'default';
    }
  }
  
  return mergedConfig;
}

/**
 * 深度合并多个对象
 * 对象递归合并，数组合并去重
 */
function deepMerge(...objects) {
  const result = {};
  
  for (const obj of objects) {
    for (const key in obj) {
      if (key.startsWith('_')) {
        // 保留内部属性
        result[key] = obj[key];
      } else if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
        // 递归合并对象
        result[key] = deepMerge(result[key] || {}, obj[key]);
      } else if (Array.isArray(obj[key])) {
        // 数组合并（去重）
        const existing = Array.isArray(result[key]) ? result[key] : [];
        result[key] = [...new Set([...existing, ...obj[key]])];
      } else {
        // 基本类型直接覆盖
        result[key] = obj[key];
      }
    }
  }
  
  return result;
}

module.exports = {
  loadConfig,
  getDefaultConfig,
  deepMerge
};

const fs = require('fs');
const path = require('path');

const DEFAULT_INNER_DICT_PATH = path.join(__dirname, 'inner.json');
const DEFAULT_TEMP_TXT_PATH = path.join(__dirname, 'temp.txt');

function loadDictTrie(dictPath) {
  const filePath = dictPath || DEFAULT_INNER_DICT_PATH;
  try {
    const raw = fs.readFileSync(filePath, 'utf8');
    const parsed = JSON.parse(raw || '{}');
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
  } catch (error) {
    return {};
  }
}

function saveDictTrie(dictPath, trie) {
  const filePath = dictPath || DEFAULT_INNER_DICT_PATH;
  const safeTrie = trie && typeof trie === 'object' && !Array.isArray(trie) ? trie : {};

  const dir = path.dirname(filePath);
  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

  const tmpPath = `${filePath}.tmp.${process.pid}`;
  fs.writeFileSync(tmpPath, `${JSON.stringify(safeTrie, null, 2)}\n`, 'utf8');
  fs.renameSync(tmpPath, filePath);
}

function normalizeWordForDict(word) {
  return String(word || '').trim().toLowerCase();
}

function extractEnglishWordsBySpaces(text) {
  const value = String(text || '');
  const map = new Map();

  const re = /(?:^|\s)([A-Za-z][A-Za-z0-9.+-]*)(?=\s|$)/g;
  for (const match of value.matchAll(re)) {
    const original = match?.[1];
    if (!original) continue;
    const normalized = normalizeWordForDict(original);
    if (!normalized) continue;
    if (normalized.length >= 3) {
      if (!map.has(normalized)) {
        map.set(normalized, original);
      }
    }
  }

  return Array.from(map, ([normalized, original]) => ({ normalized, original }));
}

function insertWordIntoTrie(trie, normalizedWord, originalWord) {
  const word = String(normalizedWord || '').trim().toLowerCase();
  if (!word) return false;

  let node = trie;
  for (const ch of word) {
    const next = node[ch];
    if (!next || typeof next !== 'object' || Array.isArray(next)) node[ch] = {};
    node = node[ch];
  }

  if (typeof node.$ === 'string' && node.$) return false;
  node.$ = String(originalWord || normalizedWord);
  return true;
}

function trieToWordList(trie) {
  const results = [];

  const walk = (node) => {
    if (!node || typeof node !== 'object' || Array.isArray(node)) return;
    if (typeof node.$ === 'string' && node.$) results.push(node.$);

    for (const [key, child] of Object.entries(node)) {
      if (key === '$') continue;
      walk(child);
    }
  };

  walk(trie);
  return Array.from(new Set(results)).sort((a, b) => a.localeCompare(b));
}

function readInnerDictionary(options) {
  const trie = loadDictTrie(options?.dictPath);
  return trieToWordList(trie);
}

function extractAndWriteInnerDictionary(text, options) {
  const words = extractEnglishWordsBySpaces(text);
  if (words.length === 0) return { words: [], added: [] };

  const trie = loadDictTrie(options?.dictPath);
  const added = [];

  for (const { normalized, original } of words) {
    const ok = insertWordIntoTrie(trie, normalized, original);
    if (ok) added.push(original);
  }

  if (added.length > 0) saveDictTrie(options?.dictPath, trie);
  return { words: words.map(w => w.original), added };
}

function extractAndWriteInnerDictionaryFromTempTxt(options) {
  const tempTxtPath = options?.tempTxtPath || DEFAULT_TEMP_TXT_PATH;

  let text = '';
  try {
    text = fs.readFileSync(tempTxtPath, 'utf8');
  } catch (error) {
    return { words: [], added: [], tempTxtPath };
  }

  if (!text || !text.trim()) return { words: [], added: [], tempTxtPath };

  const result = extractAndWriteInnerDictionary(text, { dictPath: options?.dictPath });
  return { ...result, tempTxtPath };
}

module.exports = {
  readInnerDictionary,
  extractAndWriteInnerDictionary,
  extractAndWriteInnerDictionaryFromTempTxt,
};

const fs = require('fs');
const path = require('path');

/**
 * 创建符号链接
 * @param {string} sourcePath - 源路径
 * @param {string} targetPath - 目标路径
 */
function createSymlink(sourcePath, targetPath) {
  try {
    try {
      const stats = fs.lstatSync(targetPath);
      if (stats.isSymbolicLink() || stats.isFile()) {
        fs.unlinkSync(targetPath);
      }
    } catch (e) {
    }

    fs.symlinkSync(sourcePath, targetPath);
    console.log(`已创建符号链接: ${targetPath} -> ${sourcePath}`);
  } catch (error) {
    throw new Error(`创建符号链接失败: ${error.message}`);
  }
}

module.exports = {
  createSymlink
};

const path = require('path');

/**
 * 判断文件是否应被排除
 * @param {string} filename - 文件名
 * @param {Object} config - 配置对象
 * @returns {boolean} 是否应排除
 */
function shouldExcludeFile(filename, config) {
  const excludeFiles = config?.fileFilters?.excludeFiles || [];
  return excludeFiles.includes(filename);
}

function shouldExcludeDir(dirname, config) {
  const excludeDirs = config?.fileFilters?.excludeDirs || [];
  return excludeDirs.includes(dirname);
}

/**
 * 判断文件类型是否支持
 * @param {string} filename - 文件名
 * @param {Object} config - 配置对象
 * @returns {boolean} 是否支持
 */
function isSupportedFile(filename, config) {
  const supportedExtensions = config?.fileFilters?.supportedExtensions || ['.md', '.js', '.py'];
  const ext = path.extname(filename).toLowerCase();
  return supportedExtensions.includes(ext);
}

module.exports = {
  shouldExcludeFile,
  shouldExcludeDir,
  isSupportedFile
};

const { execSync } = require('child_process');
const path = require('path');
const fs = require('fs');
const { isSupportedFile } = require('./filter');

/**
 * 检查文件是否被修改
 * @param {string} projectPath - 项目路径
 * @param {string} filePath - 文件路径
 * @param {string} targetBranch - 目标分支
 * @returns {boolean} 是否被修改
 */
function checkFileModified(projectPath, filePath, targetBranch = 'upstream/master') {
  try {
    const relativePath = path.relative(projectPath, filePath);
    const diffOutput = execSync(
      `git diff ${targetBranch} -- "${relativePath}"`,
      { cwd: projectPath, encoding: 'utf-8' }
    );

    return diffOutput.trim().length > 0;
  } catch (error) {
    return false;
  }
}

/**
 * 检测已修改的文件（与目标分支对比）
 * @param {string} projectPath - 项目路径
 * @param {string} targetBranch - 目标分支
 * @returns {Array} 已修改的文件列表
 */
function detectModifiedFiles(projectPath, targetBranch = 'upstream/master') {
  try {
    const { loadConfig } = require('./config');
    const config = loadConfig(projectPath);

    const diffOutput = execSync(
      `git diff --name-only ${targetBranch}`,
      { cwd: projectPath, encoding: 'utf-8' }
    );

    const changedFiles = diffOutput.trim().split('\n').filter(Boolean);
    const modifiedFiles = [];

    for (const file of changedFiles) {
      const filePath = path.join(projectPath, file);
      const filename = path.basename(file);

      if (fs.existsSync(filePath) && isSupportedFile(filename, config)) {
        modifiedFiles.push(filePath);
      }
    }

    return modifiedFiles;
  } catch (error) {
    console.warn(`检测修改文件失败: ${error.message}`);
    return [];
  }
}

/**
 * 恢复文件到上游版本
 * @param {string} projectPath - 项目路径
 * @param {string} filePath - 文件路径
 */
function restoreUpstreamVersion(projectPath, filePath, targetBranch = 'upstream/master') {
  try {
    const relativePath = path.relative(projectPath, filePath);
    const command = `git checkout ${targetBranch} -- "${relativePath}"`;

    execSync(command, { cwd: projectPath, stdio: 'inherit' });
    console.log(`已恢复上游版本: ${filePath}`);
  } catch (error) {
    throw new Error(`恢复上游版本失败: ${error.message}`);
  }
}

/**
 * 获取 Git 仓库根目录
 * @param {string} cwd - 起始目录（可选，默认当前工作目录）
 * @returns {string|null} Git 仓库根目录，如果不是 git 仓库则返回 null
 */
function getGitRoot(cwd = process.cwd()) {
  try {
    const root = execSync('git rev-parse --show-toplevel', {
      cwd,
      encoding: 'utf-8',
      stdio: ['pipe', 'pipe', 'ignore'] // 忽略错误输出
    }).trim();
    return root;
  } catch (error) {
    return null;
  }
}

module.exports = {
  checkFileModified,
  detectModifiedFiles,
  restoreUpstreamVersion,
  getGitRoot
};

const fs = require('fs');
const path = require('path');

function readGitignore(projectPath) {
  const gitignorePath = path.join(projectPath, '.gitignore');

  if (!fs.existsSync(gitignorePath)) {
    return [];
  }

  try {
    const content = fs.readFileSync(gitignorePath, 'utf-8');
    const lines = content.split('\n').map(line => line.trim());

    return lines.filter(line => line && !line.startsWith('#'));
  } catch (error) {
    console.warn(`警告: 无法读取 .gitignore 文件: ${error.message}`);
    return [];
  }
}

/**
 * 判断文件是否被 .gitignore 忽略
 * @param {string} filePath - 文件路径
 * @param {string} projectPath - 项目路径
 * @param {Array} gitignorePatterns - 忽略规则列表
 * @returns {boolean} 是否被忽略
 */
function isIgnoredByGitignore(filePath, projectPath, gitignorePatterns) {
  const relativePath = path.relative(projectPath, filePath);

  for (const pattern of gitignorePatterns) {
    if (relativePath.startsWith(pattern) || relativePath.includes(pattern)) {
      return true;
    }

    if (pattern.endsWith('/')) {
      const dirPattern = pattern.slice(0, -1);
      const relativeDir = path.dirname(relativePath);
      if (relativeDir === dirPattern || relativeDir.startsWith(dirPattern + '/')) {
        return true;
      }
    }

    if (pattern.includes('*')) {
      const regexPattern = pattern
        .replace(/\*/g, '.*')
        .replace(/\?/g, '.');
      const regex = new RegExp(regexPattern);
      if (regex.test(relativePath) || regex.test(path.basename(relativePath))) {
        return true;
      }
    }
  }

  return false;
}

module.exports = {
  readGitignore,
  isIgnoredByGitignore
};

const config = require('./config');
const gitignore = require('./gitignore');
const filter = require('./filter');
const todo = require('./todo');
const git = require('./git');
const valid = require('./valid');
const file = require('./file');
const parse = require('./parse');
const lang = require('./lang');
const scanner = require('./scanner');
const priority = require('./priority');

module.exports = {
  ...config,
  ...gitignore,
  ...filter,
  ...todo,
  ...git,
  ...valid,
  ...file,
  ...parse,
  ...lang,
  scanner,
  ...priority,
};

const fs = require('fs');
const path = require('path');
const { readInnerDictionary } = require('./dict');

let francPromise;

function normalizeLanguageTag(language) {
  if (!language) return '';
  const value = String(language).trim().toLowerCase();
  if (!value) return '';

  const normalized = value.replace(/_/g, '-');
  const base = normalized.split('-')[0];
  return base;
}

function normalizeTargetLanguage(targetLanguage) {
  if (!targetLanguage) return '';
  const value = String(targetLanguage).trim().toLowerCase();
  if (!value) return '';

  if (value === '中文' || value === '汉语' || value === '简体中文' || value === '繁體中文' || value === '繁体中文') {
    return 'zh';
  }
  if (value === '英文' || value === '英语' || value === 'english') return 'en';
  if (value === '日文' || value === '日语' || value === 'japanese') return 'ja';
  if (value === '韩文' || value === '韩语' || value === 'korean') return 'ko';
  if (value === '俄文' || value === '俄语' || value === 'russian') return 'ru';

  const base = normalizeLanguageTag(value);
  if (base === 'zh' || base === 'en' || base === 'ja' || base === 'ko' || base === 'ru') return base;
  return base || value;
}

function loadFranc() {
  if (!francPromise) {
    francPromise = import('franc').then(m => ({ franc: m.franc, francAll: m.francAll }));
  }
  return francPromise;
}

function getTargetFrancCodes(targetLanguage) {
  const target = normalizeTargetLanguage(targetLanguage);

  if (target === 'zh') return new Set(['cmn', 'zho', 'yue', 'wuu']);
  if (target === 'en') return new Set(['eng']);
  if (target === 'ja') return new Set(['jpn']);
  if (target === 'ko') return new Set(['kor']);
  if (target === 'ru') return new Set(['rus']);

  return new Set();
}

function getDefaultFrancOnlyList() {
  return [
    'cmn',
    'zho',
    'yue',
    'wuu',
    'eng',
    'jpn',
    'kor',
    'rus'
  ];
}

function getFrancOnlyListFromConfig(config) {
  const defaultOnly = getDefaultFrancOnlyList();
  const defaultOnlySet = new Set(defaultOnly);

  const configOnly = Array.isArray(config?.translation?.langdetectOnly) ? config.translation.langdetectOnly : [];
  const filtered = configOnly
    .map(item => String(item || '').trim().toLowerCase())
    .filter(item => defaultOnlySet.has(item));

  return filtered.length > 0 ? filtered : defaultOnly;
}

function isMarkdownFile(filePath) {
  const ext = path.extname(String(filePath || '')).toLowerCase();
  return ext === '.md' || ext === '.mdx' || ext === '.markdown';
}

function stripMarkdownTables(markdown) {
  const lines = String(markdown || '').split(/\r?\n/);
  const output = [];

  const isSeparatorLine = (line) => /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
  const looksLikeTableRow = (line) => {
    const pipeCount = (String(line).match(/\|/g) || []).length;
    return pipeCount >= 2;
  };

  let inTable = false;

  for (const line of lines) {
    if (isSeparatorLine(line)) {
      if (output.length > 0 && looksLikeTableRow(output[output.length - 1])) output.pop();
      inTable = true;
      continue;
    }

    if (inTable) {
      if (!line.trim()) continue;
      if (looksLikeTableRow(line)) continue;
      inTable = false;
    }

    output.push(line);
  }

  return output.join('\n');
}

function escapeRegExp(value) {
  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

function stripDictionaryWords(text, config) {
  const dict = readInnerDictionary({ dictPath: config?.translation?.dictPath });
  if (!Array.isArray(dict) || dict.length === 0) return text;

  const tokenChars = 'A-Za-z0-9.+-';
  const words = dict
    .map(w => String(w || '').trim())
    .filter(Boolean)
    .sort((a, b) => b.length - a.length);

  let value = String(text || '');
  for (const word of words) {
    const escaped = escapeRegExp(word);
    const re = new RegExp(`(^|[^${tokenChars}])(${escaped})(?=$|[^${tokenChars}])`, 'gi');
    value = value.replace(re, '$1');
  }

  return value;
}

function cleanMarkdownForLangdetect(markdown, config) {
  let value = String(markdown || '');

  value = value.replace(/^\uFEFF/, '');
  value = value.replace(/^---[\s\S]*?\n---\s*/m, '');
  value = value.replace(/```\w+\r?\n[\s\S]*?\r?\n```/g, ' ');
  value = value.replace(/~~~[\s\S]*?~~~/g, ' ');
  value = value.replace(/\*\*[\s\S]*?\*\*/g, ' ');
  value = value.replace(/<!--[\s\S]*?-->/g, ' ');
  value = value.replace(/!\[[^\]]*]\([^)]*\)/g, ' ');
  value = value.replace(/\[([^\]]+)]\([^)]*\)/g, '$1');
  value = value.replace(/^\[[^\]]+]:\s*\S+.*$/gm, ' ');
  value = value.replace(/`[^`]*`/g, ' ');
  value = value.replace(/<[^>]+>/g, ' ');
  value = value.replace(/^#{1,6}\s+/gm, '');
  value = value.replace(/^\s*>\s+/gm, '');
  value = value.replace(/^\s*[-*+]\s+/gm, '');
  value = value.replace(/^\s*\d+\.\s+/gm, '');

  // "1.2、1.1.2"
  value = value.replace(/\d+(?:\.\d)+\.?/g, ' ');

  // url
  value = value.replace(/https?:\/\/\S+/g, ' ');

  // table
  value = stripMarkdownTables(value);
  value = stripDictionaryWords(value, config);

  // "[] task"
  value = value.replace(/\[[xX\s]\]/g, '');

  // collapse multiple space
  value = value.replace(/\s+/g, ' ').trim();

  return value;
}

async function detectLanguageFromText(text, config) {
  if (!text) return 'unknown';
  const value = String(text);
  if (!value.trim()) return 'unknown';

  const { francAll } = await loadFranc();
  const minLengthFromConfig = Number(config?.translation?.langdetectMinLength);
  const minLength = Number.isFinite(minLengthFromConfig) && minLengthFromConfig > 0 ? minLengthFromConfig : 3;

  const minScoreFromConfig = Number(config?.translation?.langdetectMinScore);
  const minScore = Number.isFinite(minScoreFromConfig) && minScoreFromConfig >= 0 && minScoreFromConfig <= 1 ? minScoreFromConfig : 0.7;

  const only = getFrancOnlyListFromConfig(config);

  const results = francAll(value, { minLength, only });
  if (!Array.isArray(results) || results.length === 0) return 'unknown';

  const [topLang, topScore] = results[0];
  if (!topLang || topLang === 'und') return 'unknown';
  if (typeof topScore === 'number' && topScore < minScore) return 'unknown';

  return String(topLang).trim().toLowerCase();
}

function readFileHead(filePath, maxBytes) {
  const bytes = Number.isFinite(maxBytes) && maxBytes > 0 ? Math.floor(maxBytes) : 65536;
  const fd = fs.openSync(filePath, 'r');
  try {
    const buffer = Buffer.alloc(bytes);
    const read = fs.readSync(fd, buffer, 0, bytes, 0);
    return buffer.subarray(0, read).toString('utf8');
  } finally {
    fs.closeSync(fd);
  }
}

function detectLanguageFromFile(filePath, config) {
  const maxBytesFromConfig = Number(config?.translation?.langdetectMaxBytes);
  const sample = readFileHead(filePath, Number.isFinite(maxBytesFromConfig) && maxBytesFromConfig > 0 ? maxBytesFromConfig : 65536);
  const cleaned = isMarkdownFile(filePath) ? cleanMarkdownForLangdetect(sample, config) : sample;

  // console.log('[info] cleaned', cleaned)
  return detectLanguageFromText(cleaned, config);
}

function isTranslatableByLanguage(filePath, config) {
  return isFileTranslated(filePath, config).then(translated => !translated);
}

async function isFileTranslated(filePath, config) {
  const target = normalizeTargetLanguage(config?.targetLanguage || '中文');
  if (!target) return false;

  const maxBytesFromConfig = Number(config?.translation?.langdetectMaxBytes);
  const maxBytes = Number.isFinite(maxBytesFromConfig) && maxBytesFromConfig > 0 ? maxBytesFromConfig : 65536;

  let sample = '';
  try {
    sample = readFileHead(filePath, maxBytes);
  } catch (error) {
    return false;
  }

  if (isMarkdownFile(filePath)) {
    sample = cleanMarkdownForLangdetect(sample, config);
  }

  const allowed = getTargetFrancCodes(target);
  if (allowed.size === 0) return false;

  const { francAll } = await loadFranc();
  const minLengthFromConfig = Number(config?.translation?.langdetectMinLength);
  const minLength = Number.isFinite(minLengthFromConfig) && minLengthFromConfig > 0 ? minLengthFromConfig : 3;

  const only = getFrancOnlyListFromConfig(config);

  const results = francAll(sample, { minLength, only });
  if (!Array.isArray(results) || results.length === 0) return false;
  // console.log('[info] results', results)

  const topNFromConfig = Number(config?.translation?.langdetectTopN);
  const topN = Number.isFinite(topNFromConfig) && topNFromConfig > 0 ? Math.floor(topNFromConfig) : 3;

  const minScoreFromConfig = Number(config?.translation?.langdetectTopMinScore);
  const minScore = Number.isFinite(minScoreFromConfig) && minScoreFromConfig >= 0 && minScoreFromConfig <= 1 ? minScoreFromConfig : 0.9;

  const topResults = results.slice(0, topN);
  for (const [lang, score] of topResults) {
    const normalizedLang = String(lang || '').trim().toLowerCase();
    if (!allowed.has(normalizedLang)) continue;
    if (typeof score === 'number' && score >= minScore) return true;
  }

  return false;
}

module.exports = {
  normalizeLanguageTag,
  normalizeTargetLanguage,
  detectLanguageFromText,
  detectLanguageFromFile,
  isFileTranslated,
  isTranslatableByLanguage
};