【Bug已解决】openclaw: "encoding mismatch" / Unsupported charset — OpenClaw 编码不匹配解决方案

1. 问题描述

在使用 OpenClaw 读取或处理包含非 UTF-8 编码的文件时，系统报出编码不匹配错误：

# 编码不匹配 - 标准报错
$ openclaw "读取 src/legacy/config.py"
Error: encoding mismatch
File 'src/legacy/config.py' is encoded as 'gbk', expected 'utf-8'
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4

# 不支持的字符集
$ openclaw "分析数据文件"
Error: Unsupported charset
Cannot decode file with encoding 'ISO-8859-1'
Supported encodings: utf-8, ascii, gbk, gb2312, big5

# BOM 头干扰
$ openclaw "读取 config.json"
Error: Invalid JSON
Unexpected token \uFEFF in JSON at position 0
BOM header detected in UTF-8 file

# 混合编码文件
$ openclaw "分析混合内容文件"
Error: Mixed encoding detected
File contains both UTF-8 and GBK encoded sections
Cannot reliably determine primary encoding

这个问题在以下场景中特别常见：

• 遗留项目使用 GBK/GB2312/Big5 编码
• Windows 上创建的文件默认使用 ANSI 编码
• 从其他系统迁移的项目编码不一致
• 文件被不同编辑器保存为不同编码
• BOM 头导致 JSON 解析失败
• 二进制文件被误当作文本处理

2. 原因分析

OpenClaw读取文件
    ↓
尝试UTF-8解码 ←──── 默认期望UTF-8编码
    ↓
遇到非法字节序列 ←──── GBK/Big5等编码的字节
    ↓
UnicodeDecodeError ←──── 解码失败
    ↓
报告编码不匹配错误

原因分类	具体表现	占比
GBK/GB2312 编码	中文遗留项目	约 35%
BOM 头干扰	UTF-8 BOM	约 20%
ISO-8859-1	西欧编码	约 15%
Big5 编码	繁体中文	约 10%
混合编码	多编辑器保存	约 10%
Shift-JIS	日文项目	约 10%

深层原理

OpenClaw 默认使用 UTF-8 编码读取所有文本文件。UTF-8 是一种变长编码，使用 1-4 个字节表示一个 Unicode 字符。当文件使用其他编码（如 GBK，每个中文字符占 2 字节）时，OpenClaw 尝试用 UTF-8 解码会遇到非法字节序列，因为 GBK 的字节排列不符合 UTF-8 的编码规则。例如，GBK 编码的中文字"测"是 0xB2 0xE2，在 UTF-8 解码器看来这不是有效的多字节序列，因此抛出 UnicodeDecodeError。此外，UTF-8 的 BOM 头（0xEF 0xBB 0xBF，即 \uFEFF）在 JSON 文件开头会导致 JSON.parse() 失败。

3. 解决方案

方案一：自动检测并转换文件编码（最推荐）

# 使用 file 命令检测文件编码
file -i src/legacy/config.py
# 输出示例: src/legacy/config.py: text/plain; charset=iso-8859-1

# 使用 iconv 转换编码
# GBK -> UTF-8
iconv -f GBK -t UTF-8 src/legacy/config.py > src/legacy/config_utf8.py
mv src/legacy/config_utf8.py src/legacy/config.py

# 批量检测和转换
cat > convert_encoding.sh << 'EOF'
#!/bin/bash
# 批量检测并转换非 UTF-8 文件

TARGET_DIR=${1:-src}
CONVERTED=0
SKIPPED=0
FAILED=0

for f in $(find "$TARGET_DIR" -type f \( -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.java" -o -name "*.txt" -o -name "*.json" -o -name "*.yaml" -o -name "*.yml" \)); do
    # 检测编码
    ENCODING=$(file -bi "$f" | sed 's/.*charset=//')
    
    if [ "$ENCODING" = "utf-8" ] || [ "$ENCODING" = "us-ascii" ]; then
        SKIPPED=$((SKIPPED + 1))
        continue
    fi
    
    # 尝试转换为 UTF-8
    echo "转换: $f (当前编码: $ENCODING)"
    
    # 映射常见编码
    case "$ENCODING" in
        iso-8859-1|latin1)
            SOURCE_ENC="ISO-8859-1"
            ;;
        gb2312|gbk)
            SOURCE_ENC="GBK"
            ;;
        big5)
            SOURCE_ENC="BIG5"
            ;;
        shift-jis|sjis)
            SOURCE_ENC="SHIFT_JIS"
            ;;
        *)
            SOURCE_ENC="$ENCODING"
            ;;
    esac
    
    if iconv -f "$SOURCE_ENC" -t UTF-8 "$f" > "${f}.tmp" 2>/dev/null; then
        mv "${f}.tmp" "$f"
        CONVERTED=$((CONVERTED + 1))
    else
        echo "  ❌ 转换失败"
        rm -f "${f}.tmp"
        FAILED=$((FAILED + 1))
    fi
done

echo ""
echo "=== 转换结果 ==="
echo "已转换: $CONVERTED"
echo "已跳过(UTF-8): $SKIPPED"
echo "失败: $FAILED"
EOF

chmod +x convert_encoding.sh
./convert_encoding.sh src

方案二：配置 OpenClaw 支持多编码

# 配置 OpenClaw 自动检测编码
python3 -c "
import json
with open('.openclaw/config.json', 'r') as f:
    config = json.load(f)

config['encodingOptions'] = {
    'autoDetect': True,           # 自动检测文件编码
    'defaultEncoding': 'utf-8',   # 默认编码
    'supportedEncodings': [       # 支持的编码列表
        'utf-8', 'ascii', 'gbk', 'gb2312', 
        'big5', 'shift_jis', 'iso-8859-1',
        'utf-16', 'utf-16le', 'utf-16be'
    ],
    'autoConvert': True,          # 自动转换为UTF-8
    'stripBOM': True,             # 移除BOM头
    'fallbackEncoding': 'gbk'     # 检测失败时的回退编码
}

with open('.openclaw/config.json', 'w') as f:
    json.dump(config, f, indent=2)
print('多编码支持已配置: 自动检测+自动转换+BOM移除')
"

# 指定文件编码
openclaw --encoding gbk "读取 src/legacy/config.py"
openclaw --encoding big5 "读取繁体文件"
openclaw --encoding shift_jis "读取日文文件"

方案三：使用 Python chardet 自动检测编码

# 创建高级编码检测工具
# pip install chardet

import chardet
import os

class EncodingDetector:
    """高级文件编码检测器"""
    
    # 常见编码的优先级
    ENCODING_PRIORITY = {
        'utf-8': 1,
        'ascii': 2,
        'gbk': 3,
        'gb2312': 4,
        'big5': 5,
        'shift_jis': 6,
        'iso-8859-1': 7,
        'utf-16': 8,
    }
    
    @classmethod
    def detect_file(cls, filepath, sample_size=65536):
        """检测文件编码"""
        with open(filepath, 'rb') as f:
            raw_data = f.read(sample_size)
        
        # 使用 chardet 检测
        result = chardet.detect(raw_data)
        
        encoding = result['encoding']
        confidence = result['confidence']
        
        # 特殊处理
        if encoding == 'ascii':
            encoding = 'utf-8'  # ASCII 是 UTF-8 的子集
        
        # GB2312 和 GBK 的区分
        if encoding == 'GB2312':
            encoding = 'gbk'  # GBK 是 GB2312 的超集
        
        return {
            'encoding': encoding,
            'confidence': confidence,
            'usable': confidence > 0.7
        }
    
    @classmethod
    def convert_to_utf8(cls, filepath, backup=True):
        """将文件转换为 UTF-8"""
        detection = cls.detect_file(filepath)
        
        if detection['encoding'] == 'utf-8':
            return True, '已经是 UTF-8'
        
        if not detection['usable']:
            return False, f'编码检测置信度低: {detection}'
        
        source_encoding = detection['encoding']
        
        try:
            # 读取原始内容
            with open(filepath, 'r', encoding=source_encoding) as f:
                content = f.read()
            
            # 备份原文件
            if backup:
                backup_path = filepath + '.bak'
                with open(filepath, 'rb') as f:
                    import shutil
                    shutil.copy2(filepath, backup_path)
            
            # 写入 UTF-8
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(content)
            
            return True, f'转换成功: {source_encoding} -> utf-8'
        except Exception as e:
            return False, f'转换失败: {e}'
    
    @classmethod
    def scan_project(cls, root_dir, exclude_dirs=None):
        """扫描项目中的非UTF-8文件"""
        if exclude_dirs is None:
            exclude_dirs = {'node_modules', '.git', 'dist', 'build', '__pycache__'}
        
        results = {'utf8': [], 'non_utf8': [], 'unknown': []}
        
        for dirpath, dirnames, filenames in os.walk(root_dir):
            dirnames[:] = [d for d in dirnames if d not in exclude_dirs]
            
            for filename in filenames:
                ext = os.path.splitext(filename)[1].lower()
                if ext not in ('.py', '.js', '.ts', '.java', '.txt', '.json', '.yaml', '.yml', '.md'):
                    continue
                
                filepath = os.path.join(dirpath, filename)
                detection = cls.detect_file(filepath)
                
                if detection['encoding'] == 'utf-8':
                    results['utf8'].append(filepath)
                elif detection['usable']:
                    results['non_utf8'].append({
                        'file': filepath,
                        'encoding': detection['encoding'],
                        'confidence': detection['confidence']
                    })
                else:
                    results['unknown'].append(filepath)
        
        return results

# 使用示例
if __name__ == "__main__":
    import sys
    target = sys.argv[1] if len(sys.argv) > 1 else '.'
    
    results = EncodingDetector.scan_project(target)
    
    print(f"=== 编码扫描结果 ===")
    print(f"UTF-8: {len(results['utf8'])} 个文件")
    print(f"非UTF-8: {len(results['non_utf8'])} 个文件")
    print(f"未知: {len(results['unknown'])} 个文件")
    
    if results['non_utf8']:
        print(f"\n非UTF-8文件列表:")
        for item in results['non_utf8'][:20]:
            print(f"  {item['encoding']} ({item['confidence']:.0%}) {item['file']}")
    
    # 批量转换
    if results['non_utf8']:
        print(f"\n开始批量转换...")
        for item in results['non_utf8']:
            success, msg = EncodingDetector.convert_to_utf8(item['file'])
            status = '✅' if success else '❌'
            print(f"  {status} {item['file']}: {msg}")

方案四：处理 BOM 头问题

# 检测文件是否有 BOM 头
python3 -c "
import sys
filepath = sys.argv[1] if len(sys.argv) > 1 else 'config.json'
with open(filepath, 'rb') as f:
    first_bytes = f.read(4)
    
bom_types = {
    b'\\xef\\xbb\\xbf': 'UTF-8 BOM',
    b'\\xff\\xfe': 'UTF-16 LE BOM', 
    b'\\xfe\\xff': 'UTF-16 BE BOM',
    b'\\xff\\xfe\\x00\\x00': 'UTF-32 LE BOM',
    b'\\x00\\x00\\xfe\\xff': 'UTF-32 BE BOM',
}

detected = None
for bom, name in bom_types.items():
    if first_bytes.startswith(bom):
        detected = name
        break

if detected:
    print(f'检测到: {detected}')
    print(f'前4字节: {first_bytes.hex()}')
else:
    print('无 BOM 头')
    print(f'前4字节: {first_bytes.hex()}')
" config.json

# 移除 BOM 头
python3 -c "
import sys
filepath = sys.argv[1]
with open(filepath, 'r', encoding='utf-8-sig') as f:  # utf-8-sig 自动移除BOM
    content = f.read()
with open(filepath, 'w', encoding='utf-8') as f:      # 写入无BOM的UTF-8
    f.write(content)
print(f'BOM 头已移除: {filepath}')
" config.json

# 批量移除 BOM 头
find . -name "*.json" -o -name "*.py" -o -name "*.js" | while read f; do
    # 检查是否有BOM
    if [ "$(head -c 3 "$f" | xxd -p)" = "efbbbf" ]; then
        echo "移除BOM: $f"
        sed -i '1s/^\xEF\xBB\xBF//' "$f"
    fi
done

方案五：统一项目编码规范

# 在项目中添加 .editorconfig 统一编码
cat > .editorconfig << 'EOF'
root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.{py,js,ts,java}]
indent_style = space
indent_size = 4

[*.{json,yaml,yml}]
indent_style = space
indent_size = 2

[*.md]
trim_trailing_whitespace = false
EOF

echo ".editorconfig 已创建，所有文件统一使用 UTF-8 编码"

# 配置 Git 属性确保编码一致
cat >> .gitattributes << 'EOF'
* text=auto encoding=UTF-8
*.py text encoding=UTF-8
*.js text encoding=UTF-8
*.ts text encoding=UTF-8
*.json text encoding=UTF-8
*.yaml text encoding=UTF-8
*.md text encoding=UTF-8
EOF

# 配置 VS Code 编码
cat > .vscode/settings.json << 'EOF'
{
    "files.encoding": "utf8",
    "files.autoGuessEncoding": true,
    "files.candidateGuessEncodings": [
        "utf8", "gbk", "gb2312", "big5", "shiftjis", "iso88591"
    ],
    "files.insertFinalNewline": true,
    "files.trimTrailingWhitespace": true
}
EOF

echo "VS Code 编码配置已创建"

方案六：流式编码转换处理大文件

# 创建流式编码转换工具（适用于大文件）
import codecs

class StreamingEncodingConverter:
    """流式编码转换，避免大文件内存问题"""
    
    @staticmethod
    def convert(filepath, source_encoding, target_encoding='utf-8', 
                chunk_size=8192):
        """流式转换文件编码"""
        temp_path = filepath + '.converting'
        
        try:
            with codecs.open(filepath, 'r', encoding=source_encoding) as src:
                with codecs.open(temp_path, 'w', encoding=target_encoding) as dst:
                    while True:
                        chunk = src.read(chunk_size)
                        if not chunk:
                            break
                        dst.write(chunk)
            
            # 替换原文件
            import os
            os.replace(temp_path, filepath)
            return True
            
        except Exception as e:
            print(f"转换失败: {e}")
            # 清理临时文件
            if os.path.exists(temp_path):
                os.remove(temp_path)
            return False
    
    @staticmethod
    def safe_read(filepath, fallback_encodings=None):
        """安全读取文件，自动尝试多种编码"""
        if fallback_encodings is None:
            fallback_encodings = ['utf-8', 'gbk', 'gb2312', 'big5', 
                                  'iso-8859-1', 'shift_jis']
        
        for encoding in fallback_encodings:
            try:
                with open(filepath, 'r', encoding=encoding) as f:
                    content = f.read(1024)  # 先读一小段测试
                    # 验证内容是否合理（检查是否有乱码特征）
                    if '\ufffd' not in content:  # 无替换字符
                        # 重新完整读取
                        with open(filepath, 'r', encoding=encoding) as f:
                            return f.read(), encoding
            except (UnicodeDecodeError, UnicodeError):
                continue
        
        # 所有编码都失败，使用 errors='replace' 模式
        with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
            return f.read(), 'utf-8 (with replacements)'

# 使用示例
if __name__ == "__main__":
    import sys
    
    if len(sys.argv) > 1:
        filepath = sys.argv[1]
        content, encoding = StreamingEncodingConverter.safe_read(filepath)
        print(f"编码: {encoding}")
        print(f"内容前200字符: {content[:200]}")

4. 各方案对比总结

方案	适用场景	推荐指数
方案一：iconv转换	快速修复	⭐⭐⭐⭐⭐
方案二：配置多编码	混合编码项目	⭐⭐⭐⭐
方案三：chardet检测	精确检测	⭐⭐⭐⭐⭐
方案四：BOM处理	JSON BOM 问题	⭐⭐⭐⭐
方案五：统一规范	长期预防	⭐⭐⭐⭐
方案六：流式转换	大文件	⭐⭐⭐

5. 常见问题 FAQ

5.1 Windows 上文件编码问题更频繁

Windows 默认使用系统代码页（中文系统为 GBK/CP936）：

# 检查系统代码页
chcp
# 输出示例: 936 (GBK)

# PowerShell 读取 GBK 文件
$content = [System.IO.File]::ReadAllText("config.py", [System.Text.Encoding]::GetEncoding("gbk"))
[System.IO.File]::WriteAllText("config_utf8.py", $content, [System.Text.Encoding]::UTF8)

# 设置 PowerShell 默认编码为 UTF-8
$PSDefaultParameterValues['Out-File:Encoding'] = 'utf8'
$PSDefaultParameterValues['Set-Content:Encoding'] = 'utf8'

# VS Code 设置
# "files.encoding": "utf8"
# "files.autoGuessEncoding": true

5.2 Docker 容器中缺少 iconv

精简镜像可能没有 iconv 命令：

# 安装 iconv 和 locales
FROM node:18-slim
RUN apt-get update && apt-get install -y \
    libc6 \
    locales \
    && rm -rf /var/lib/apt/lists/*
RUN locale-gen en_US.UTF-8 zh_CN.UTF-8
ENV LANG=en_US.UTF-8
ENV LC_ALL=en_US.UTF-8

# 或者使用 Python 进行编码转换
# RUN pip install chardet

5.3 CI/CD 中编码转换导致 Git diff 噪音

批量编码转换会产生大量 diff：

# 分离编码转换提交
steps:
  - name: Convert encoding
    run: |
      # 只转换需要转换的文件
      for f in $(find src/legacy -name "*.py"); do
        ENC=$(file -bi "$f" | sed 's/.*charset=//')
        if [ "$ENC" != "utf-8" ] && [ "$ENC" != "us-ascii" ]; then
          iconv -f GBK -t UTF-8 "$f" > "${f}.tmp" && mv "${f}.tmp" "$f"
        fi
      done
  
  - name: Commit encoding changes
    run: |
      git config user.name "CI Bot"
      git config user.email "ci@example.com"
      git add -A
      git commit -m "chore: convert legacy files to UTF-8" || true

5.4 JSON 文件有 BOM 头导致解析失败

BOM 是 JSON 解析的常见问题：

# 快速检测和修复 JSON BOM
python3 -c "
import json
import os

json_files = []
for root, dirs, files in os.walk('.'):
    if 'node_modules' in root or '.git' in root:
        continue
    for f in files:
        if f.endswith('.json'):
            json_files.append(os.path.join(root, f))

fixed = 0
for filepath in json_files:
    try:
        with open(filepath, 'rb') as f:
            raw = f.read()
        if raw[:3] == b'\xef\xbb\xbf':
            # 有BOM，移除
            with open(filepath, 'wb') as f:
                f.write(raw[3:])
            fixed += 1
            print(f'移除BOM: {filepath}')
        # 验证JSON
        with open(filepath, 'r', encoding='utf-8') as f:
            json.load(f)
    except json.JSONDecodeError as e:
        print(f'JSON错误: {filepath} - {e}')
    except Exception as e:
        print(f'读取失败: {filepath} - {e}')

print(f'\n共修复 {fixed} 个JSON文件的BOM问题')
"

5.5 中英文混合文件的编码检测不准

chardet 可能误判中英文混合内容：

# 使用多种方法交叉验证
def detect_encoding_robust(filepath):
    """使用多种方法检测编码"""
    import chardet
    
    # 方法1: chardet
    with open(filepath, 'rb') as f:
        raw = f.read()
    chardet_result = chardet.detect(raw)
    
    # 方法2: 尝试实际解码
    candidates = ['utf-8', 'gbk', 'gb2312', 'big5', 'iso-8859-1']
    decodable = []
    for enc in candidates:
        try:
            raw.decode(enc)
            decodable.append(enc)
        except UnicodeDecodeError:
            pass
    
    # 方法3: 检查中文字符特征
    has_chinese = False
    for enc in ['gbk', 'big5']:
        try:
            text = raw.decode(enc)
            # 检查是否有合理的中文字符
            chinese_count = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
            if chinese_count > 5:
                has_chinese = True
                break
        except UnicodeDecodeError:
            pass
    
    # 综合判断
    if 'utf-8' in decodable and chardet_result['encoding'] == 'utf-8':
        return 'utf-8', 1.0
    elif has_chinese and 'gbk' in decodable:
        return 'gbk', 0.9
    elif len(decodable) == 1:
        return decodable[0], 0.7
    else:
        return chardet_result['encoding'], chardet_result['confidence']

5.6 团队中编码不统一导致频繁冲突

不同开发者的编辑器默认编码不同：

# 在 pre-commit hook 中检查编码
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
# 检查提交的文件是否为 UTF-8

for f in $(git diff --cached --name-only --diff-filter=ACM); do
    if [ -f "$f" ]; then
        ENC=$(file -bi "$f" | sed 's/.*charset=//')
        if [ "$ENC" != "utf-8" ] && [ "$ENC" != "us-ascii" ]; then
            echo "❌ 文件编码不是 UTF-8: $f ($ENC)"
            echo "   请使用 iconv -f $ENC -t UTF-8 转换后重新提交"
            exit 1
        fi
    fi
done
echo "✅ 编码检查通过"
EOF

chmod +x .git/hooks/pre-commit
echo "pre-commit 编码检查 hook 已安装"

5.7 数据库导出文件的编码问题

数据库导出可能使用不同编码：

# MySQL 导出指定编码
mysqldump --default-character-set=utf8mb4 -u root -p database > dump.sql

# 如果导出文件是 GBK
iconv -f GBK -t UTF-8 dump_gbk.sql > dump_utf8.sql

# PostgreSQL 导出
pg_dump --encoding=UTF8 database > dump.sql

# CSV 文件编码转换
python3 -c "
import pandas as pd
# 读取可能非UTF-8的CSV
try:
    df = pd.read_csv('data.csv', encoding='utf-8')
except UnicodeDecodeError:
    df = pd.read_csv('data.csv', encoding='gbk')
# 保存为UTF-8
df.to_csv('data_utf8.csv', index=False, encoding='utf-8')
print('CSV已转换为UTF-8')
"

5.8 OpenClaw 配置文件本身编码错误

配置文件编码错误会导致 OpenClaw 无法启动：

# 检查配置文件编码
file -bi .openclaw/config.json

# 如果不是 UTF-8，转换它
ENC=$(file -bi .openclaw/config.json | sed 's/.*charset=//')
if [ "$ENC" != "utf-8" ] && [ "$ENC" != "us-ascii" ]; then
    echo "配置文件编码: $ENC，正在转换为 UTF-8..."
    iconv -f "$ENC" -t UTF-8 .openclaw/config.json > .openclaw/config_utf8.json
    mv .openclaw/config_utf8.json .openclaw/config.json
    echo "转换完成"
fi

# 验证 JSON 格式
python3 -c "import json; json.load(open('.openclaw/config.json')); print('配置文件JSON有效')"

排查清单速查表

□ 1. 使用 file -bi 检测文件编码
□ 2. 使用 iconv 转换非 UTF-8 文件
□ 3. 配置 OpenClaw autoDetect=True 自动检测编码
□ 4. 检查 JSON 文件是否有 BOM 头
□ 5. 使用 chardet 精确检测编码
□ 6. 创建 .editorconfig 统一编码规范
□ 7. 配置 .gitattributes 确保编码一致
□ 8. 安装 pre-commit hook 检查编码
□ 9. VS Code 设置 autoGuessEncoding=true
□ 10. 批量转换后统一提交避免 diff 噪音

6. 总结

1. 最常见原因：中文遗留项目使用 GBK/GB2312 编码（35%），OpenClaw 默认期望 UTF-8
2. 快速修复：使用 iconv -f GBK -t UTF-8 转换文件编码
3. 自动检测：配置 autoDetect: true 和 autoConvert: true 让 OpenClaw 自动处理
4. BOM 问题：使用 utf-8-sig 编码读取或 sed 移除 BOM 头，特别注意 JSON 文件
5. 最佳实践建议：创建 .editorconfig 和 .gitattributes 统一项目编码规范，安装 pre-commit hook 阻止非 UTF-8 文件提交

故障排查流程图

flowchart TD
    A[编码不匹配] --> B[检测文件编码]
    B --> C[file -bi filename]
    C --> D{是UTF-8?}
    D -->|是| E[检查BOM头]
    D -->|否| F[转换为UTF-8]
    E --> G{有BOM?}
    G -->|是| H[移除BOM]
    G -->|否| I[检查混合编码]
    H --> J[openclaw测试]
    F --> K[iconv -f原编码 -t UTF-8]
    K --> L[批量转换]
    L --> J
    I --> M{混合编码?}
    M -->|是| N[chardet精确检测]
    M -->|否| O[配置autoDetect]
    N --> P[逐段转换]
    P --> J
    O --> Q[配置fallbackEncoding]
    Q --> J
    J --> R{成功?}
    R -->|是| S[✅ 问题解决]
    R -->|否| T[创建.editorconfig]
    T --> U[配置.gitattributes]
    U --> V[安装pre-commit hook]
    V --> W[团队统一编码]
    W --> S