# 使用多个词典
aspell check --mode=markdown \
    --personal=.aspell/project.pws \
    --extra-dicts=.aspell/tech.pws \
    --extra-dicts=.aspell/names.pws \
    document.md

# 小写条目演示
# .aspell/tech.pws
api         # 匹配 api、Api、API
kubernetes  # 匹配 kubernetes、Kubernetes、KUBERNETES
oauth       # 匹配 oauth、OAuth、OAUTH

#!/bin/bash
# dict-audit.sh — 词典质量审查

DICT="$1"
if [ -z "$DICT" ] || [ ! -f "$DICT" ]; then
    echo "用法: $0 <dictionary.pws>"
    exit 1
fi

echo "=== 词典审查: $DICT ==="

# 统计
TOTAL=$(tail -n +2 "$DICT" | grep -c '.')
echo "总词数: $TOTAL"

# 检查重复
DUPES=$(tail -n +2 "$DICT" | sort | uniq -d)
if [ -n "$DUPES" ]; then
    echo ""
    echo "重复条目:"
    echo "$DUPES" | sed 's/^/  /'
fi

# 检查大写开头的条目（应改用小写）
UPPER=$(tail -n +2 "$DICT" | grep '^[A-Z]')
if [ -n "$UPPER" ]; then
    echo ""
    echo "大写开头的条目（建议改用小写）:"
    echo "$UPPER" | sed 's/^/  /'
fi

# 检查过短的条目（可能是误添加）
SHORT=$(tail -n +2 "$DICT" | grep -E '^.{1}$')
if [ -n "$SHORT" ]; then
    echo ""
    echo "单字符条目:"
    echo "$SHORT" | sed 's/^/  /'
fi

# 检查包含特殊字符的条目
SPECIAL=$(tail -n +2 "$DICT" | grep '[^a-zA-Z-]')
if [ -n "$SPECIAL" ]; then
    echo ""
    echo "包含特殊字符的条目:"
    echo "$SPECIAL" | sed 's/^/  /'
fi

echo ""
echo "=== 审查完成 ==="

#!/bin/bash
# dict-sync.sh — 多词典合并同步

SOURCE_DICTS=(
    "~/.aspell.en_US.pws"
    "./.aspell/project.pws"
    "./.aspell/tech.pws"
)

OUTPUT="/tmp/merged-dict.pws"

# 合并所有词典
{
    for dict in "${SOURCE_DICTS[@]}"; do
        expanded=$(eval echo "$dict")
        if [ -f "$expanded" ]; then
            tail -n +2 "$expanded"
        fi
    done
} | sort -u > /tmp/merged-words.txt

COUNT=$(wc -l < /tmp/merged-words.txt)

{
    echo "personal_ws-1.1 en $COUNT"
    cat /tmp/merged-words.txt
} > "$OUTPUT"

rm /tmp/merged-words.txt
echo "合并词典: $OUTPUT ($COUNT 个单词)"

# CI 环境使用 ultra 模式（最快）
aspell list --sug-mode=ultra < document.md

# 日常编辑使用 fast 模式
aspell check --sug-mode=fast document.md

# 精细校对使用 bad-spellers 模式
aspell check --sug-mode=bad-spellers manuscript.txt

# 忽略太短的单词（通常不是拼写错误）
aspell list --ignore=3 < document.md

# 忽略大小写
aspell list --ignore-case < document.md

# 忽略包含数字的单词
# （Aspell 默认会检查这类词，可以过滤掉）
aspell list < document.md | grep -v '[0-9]'

# 批量检查时，使用单次进程而非多次启动
# 差的做法（每次启动新进程）：
for word in word1 word2 word3; do
    echo "$word" | aspell -a
done

# 好的做法（单次进程）：
echo -e "word1\nword2\nword3" | aspell -a

# 管道批量检查脚本
#!/bin/bash
# batch-check.sh — 高效批量检查

INPUT_FILE="$1"

# 单次进程检查所有单词
ERRORS=$(cat "$INPUT_FILE" | aspell -a --sug-mode=ultra | \
    grep -E '^[&#]' | \
    sed 's/& \([^ ]*\).*/\1/' | \
    sed 's/# \([^ ]*\).*/\1/')

if [ -n "$ERRORS" ]; then
    echo "拼写错误:"
    echo "$ERRORS"
fi

# 分块检查大文件
#!/bin/bash
# check-large-file.sh — 分块处理大文件

FILE="$1"
CHUNK_SIZE=1000  # 每次检查 1000 行

TOTAL_LINES=$(wc -l < "$FILE")
CHUNKS=$(( (TOTAL_LINES + CHUNK_SIZE - 1) / CHUNK_SIZE ))

echo "文件: $FILE ($TOTAL_LINES 行, $CHUNKS 块)"

for ((i=0; i<CHUNKS; i++)); do
    START=$((i * CHUNK_SIZE + 1))
    END=$(( (i + 1) * CHUNK_SIZE ))

    ERRORS=$(sed -n "${START},${END}p" "$FILE" | aspell list --sug-mode=ultra 2>/dev/null)

    if [ -n "$ERRORS" ]; then
        echo "块 $((i+1))/$CHUNKS (行 $START-$END):"
        echo "$ERRORS" | sort -u | sed 's/^/  /'
    fi
done

#!/bin/bash
# benchmark.sh — Aspell 性能基准测试

echo "=== Aspell 性能基准测试 ==="

# 生成测试数据
TEST_FILE="/tmp/test_words.txt"
seq 1 10000 | while read n; do
    echo "word$n"
done > "$TEST_FILE"

# 测试不同模式
for mode in ultra fast normal; do
    echo ""
    echo "模式: $mode"
    time aspell list --sug-mode="$mode" < "$TEST_FILE" > /dev/null 2>&1
done

# 测试管道模式
echo ""
echo "管道模式 (10000 个单词):"
time cat "$TEST_FILE" | aspell -a --sug-mode=ultra > /dev/null 2>&1

rm "$TEST_FILE"

# 策略 1：使用小写词典条目（推荐）
# 在 .pws 中使用 "api" 而非 "API"，这样所有大小写变体都通过

# 策略 2：使用替换对（.prepl）
# 将常见拼写错误映射到正确形式
cat > ~/.aspell.en_US.prepl << 'EOF'
personal_repl-1.1 en 2
teh -> the
recieve -> receive
EOF

# 策略 3：使用过滤器
# 对 HTML/TeX/Markdown 文件使用正确的过滤器
aspell check --mode=html page.html
aspell check --mode=tex paper.tex

# 策略 4：忽略特定模式
# 忽略全大写单词（通常是缩写）
aspell list < file.txt | grep -v '^[A-Z]\+$'

# 策略 5：忽略包含连字符的词
aspell list < file.txt | grep -v '-'

#!/bin/bash
# collect-false-positives.sh — 收集潜在误报并生成词典建议

DOCS_DIR="$1"
KNOWN_DICT="$2"  # 已知正确的词典

echo "=== 误报收集器 ==="
echo "扫描目录: $DOCS_DIR"

# 收集所有拼写错误
ALL_ERRORS=$(find "$DOCS_DIR" -name "*.md" -exec \
    aspell list --mode=markdown --sug-mode=ultra {} \; | sort -u)

echo "总错误数: $(echo "$ALL_ERRORS" | wc -l)"

# 排除已有词典中的词
if [ -n "$KNOWN_DICT" ] && [ -f "$KNOWN_DICT" ]; then
    FILTERED=$(comm -23 <(echo "$ALL_ERRORS") <(tail -n +2 "$KNOWN_DICT" | sort))
    echo "去重后: $(echo "$FILTERED" | wc -l)"
else
    FILTERED="$ALL_ERRORS"
fi

# 统计词频
echo ""
echo "高频未知词 (可能需要加入词典):"
find "$DOCS_DIR" -name "*.md" -exec \
    aspell list --mode=markdown --sug-mode=ultra {} \; | \
    sort | uniq -c | sort -rn | head -20

echo ""
echo "建议：将上述高频词加入项目词典"

#!/usr/bin/env python3
"""smart_filter.py — 智能误报过滤器"""

import re
from typing import List, Set


def is_likely_false_positive(word: str) -> bool:
    """判断单词是否可能是误报"""
    # 1. 全大写（可能是缩写）
    if word.isupper() and len(word) <= 5:
        return True

    # 2. 包含数字
    if re.search(r'\d', word):
        return True

    # 3. 混合大小写（可能是代码标识符）
    if re.match(r'^[a-z]+[A-Z]', word):
        return True

    # 4. 包含下划线（可能是代码标识符）
    if '_' in word:
        return True

    # 5. 太短的词（1-2 个字符）
    if len(word) <= 2:
        return True

    # 6. URL 模式
    if re.match(r'https?://', word):
        return True

    # 7. 文件路径模式
    if '/' in word or '\\' in word:
        return True

    return False


def filter_errors(errors: List[str]) -> tuple:
    """过滤误报，返回 (真实错误, 可能误报)"""
    real_errors = []
    likely_false_positives = []

    for word in errors:
        if is_likely_false_positive(word):
            likely_false_positives.append(word)
        else:
            real_errors.append(word)

    return real_errors, likely_false_positives


# 使用示例
errors = [
    "teh",          # 真实错误
    "API",          # 可能误报（全大写缩写）
    "recieve",      # 真实错误
    "camelCase",    # 可能误报（代码标识符）
    "https://x.com", # 可能误报（URL）
    "programing",   # 真实错误
]

real, false_pos = filter_errors(errors)

print("真实拼写错误:")
for w in real:
    print(f"  ✗ {w}")

print("\n可能的误报:")
for w in false_pos:
    print(f"  ? {w}")

# .aspell/CONTRIBUTING.md — 词典贡献指南

## 如何添加新词

1. 编辑 `.aspell/project.pws`
2. 在文件末尾添加新词（按字母序插入更好）
3. 使用**小写形式**（如 `api` 而非 `API`）
4. 提交 PR 并说明该词的含义

## 命名规范

- 技术术语 → `.aspell/tech.pws`
- 人名/组织名 → `.aspell/names.pws`
- 项目专用词 → `.aspell/project.pws`
- 缩写词 → `.aspell/abbreviations.pws`

## 禁止添加

- 明显的拼写错误
- 只在单个文件中出现的临时词
- 过于生僻的术语（应使用个人词典）

# .github/workflows/dict-review.yml
name: Dictionary Review

on:
  pull_request:
    paths:
      - '.aspell/**'

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Check dictionary format
        run: |
          for dict in .aspell/*.pws; do
            echo "检查: $dict"

            # 检查文件头
            head -1 "$dict" | grep -q "personal_ws" || {
              echo "::error file=$dict::缺少文件头"
              exit 1
            }

            # 检查重复
            DUPES=$(tail -n +2 "$dict" | sort | uniq -d)
            if [ -n "$DUPES" ]; then
              echo "::warning file=$dict::发现重复条目"
              echo "$DUPES"
            fi
          done

      - name: Show diff
        run: |
          git diff .aspell/ | head -50

# 错误做法：在词典中存储密码或 API 密钥
# .aspell/project.pws
mysecretpassword123
sk-abc123def456

# 正确做法：只存储公开的术语
# .aspell/project.pws
api
kubernetes

# 确保个人词典权限正确
chmod 600 ~/.aspell.en_US.pws

# 项目词典可以是 644（公开可读）
chmod 644 .aspell/project.pws

# 在 CI 中不要暴露个人词典路径
# 使用项目级词典而非全局个人词典
- name: Spellcheck
  run: |
    aspell list --personal=.aspell/project.pws < file.md
    # 不要使用: --personal=~/.aspell.en_US.pws

#!/bin/bash
# aspell-diag.sh — Aspell 诊断工具

echo "=== Aspell 诊断 ==="
echo ""

# 1. 基本信息
echo "1. 基本信息"
if command -v aspell &>/dev/null; then
    echo "   版本: $(aspell --version 2>&1 | head -1)"
    echo "   路径: $(which aspell)"
else
    echo "   ✗ aspell 未找到"
    exit 1
fi

# 2. 配置信息
echo ""
echo "2. 配置路径"
echo "   数据目录: $(aspell config data-dir 2>/dev/null)"
echo "   词典目录: $(aspell config dict-dir 2>/dev/null)"
echo "   过滤器目录: $(aspell config filter-dir 2>/dev/null)"

# 3. 已安装词典
echo ""
echo "3. 已安装词典"
aspell dump dicts 2>/dev/null | sed 's/^/   /'

# 4. 已安装过滤器
echo ""
echo "4. 已安装过滤器"
aspell dump filters 2>/dev/null | sed 's/^/   /'

# 5. 个人词典
echo ""
echo "5. 个人词典"
for dict in ~/.aspell.*.pws; do
    if [ -f "$dict" ]; then
        WORDS=$(tail -n +2 "$dict" | wc -l)
        echo "   $dict ($WORDS 个单词)"
    fi
done

# 6. 基本功能测试
echo ""
echo "6. 功能测试"

# 管道模式测试
RESULT=$(echo "hello" | aspell -a 2>&1 | tail -1)
if echo "$RESULT" | grep -q '^\*'; then
    echo "   ✓ 管道模式正常"
else
    echo "   ✗ 管道模式异常: $RESULT"
fi

# 建议测试
SUGGESTIONS=$(echo "teh" | aspell -a 2>&1 | tail -1)
if echo "$SUGGESTIONS" | grep -q 'the'; then
    echo "   ✓ 建议功能正常"
else
    echo "   ✗ 建议功能异常: $SUGGESTIONS"
fi

# 7. 系统信息
echo ""
echo "7. 系统信息"
echo "   操作系统: $(uname -s) $(uname -r)"
echo "   Locale: $(locale charmap 2>/dev/null || echo 'N/A')"
echo "   TERM: $TERM"

echo ""
echo "=== 诊断完成 ==="