#!/bin/bash
# .git/hooks/post-merge - 合并后自动更新标签
# .git/hooks/post-checkout - 切换分支后自动更新标签
# .git/hooks/post-rewrite - rebase 后自动更新标签

PROJECT_ROOT="$(git rev-parse --show-toplevel)"
TAGS_FILE="$PROJECT_ROOT/.tags"

# 后台生成标签（不阻塞 git 操作）
(
    cd "$PROJECT_ROOT" || exit
    ctags -R \
        --fields=+S+s+n \
        --extras=+q \
        --sort=yes \
        --exclude=.git \
        --exclude=node_modules \
        --exclude=vendor \
        --exclude=.venv \
        -f "$TAGS_FILE" \
        . 2>/dev/null
    echo "Updated $TAGS_FILE ($(wc -l < "$TAGS_FILE") tags)"
) &

echo "Regenerating tags in background..."

# 安装 git hooks
chmod +x .git/hooks/post-merge
chmod +x .git/hooks/post-checkout
chmod +x .git/hooks/post-rewrite

# 或者使用符号链接（便于版本控制）
mkdir -p .githooks
# 将 hook 脚本放在 .githooks/ 目录
git config core.hooksPath .githooks

#!/bin/bash
# watch_and_tag.sh - 文件变更时自动更新标签

PROJECT_ROOT="$(pwd)"
TAGS_FILE="$PROJECT_ROOT/.tags"

echo "Watching $PROJECT_ROOT for changes..."
echo "Tags file: $TAGS_FILE"

# 初始生成
ctags -R --fields=+S+s+n --sort=yes -f "$TAGS_FILE" .
echo "Initial tags generated ($(wc -l < "$TAGS_FILE") tags)"

# 监视文件变更并增量更新
inotifywait -m -r -e modify,create,delete,move \
    --exclude '(\.git|node_modules|__pycache__|\.tags)' \
    "$PROJECT_ROOT" | while read -r directory event filename; do

    filepath="$directory$filename"

    # 检查文件是否应被索引
    case "$filename" in
        *.c|*.h|*.cpp|*.hpp|*.py|*.js|*.ts|*.go|*.rs|*.java)
            echo "[$(date +%H:%M:%S)] $event: $filepath"
            # 增量更新
            ctags --append=yes -f "$TAGS_FILE" "$filepath" 2>/dev/null
            ;;
    esac
done

# Makefile - Ctags 目标

.PHONY: tags ctags clean-tags

# 生成 Ctags 标签文件
tags:
	ctags -R \
		--fields=+S+s+n \
		--extras=+q \
		--sort=yes \
		--exclude=.git \
		--exclude=node_modules \
		--exclude=vendor \
		--exclude=build \
		--exclude=dist \
		--exclude=.venv \
		.
	@echo "Generated tags: $$(wc -l < tags) entries"

# 增量更新（只更新修改的文件）
tags-incremental:
	@git diff --name-only HEAD~1 | while read f; do \
		if [ -f "$$f" ]; then \
			ctags --append=yes -f tags "$$f" 2>/dev/null; \
		fi; \
	done
	@echo "Tags updated incrementally"

# 清理
clean-tags:
	rm -f tags TAGS .tags
	@echo "Cleaned tags files"

# 生成 ctags + cscope
full-index: tags
	find . -name "*.[ch]" -o -name "*.[ch]pp" | grep -v .git > cscope.files
	cscope -b -q -i cscope.files
	@echo "Generated cscope database"

# 统计信息
tags-stats:
	@echo "=== Tags Statistics ==="
	@echo "Total tags: $$(grep -cv '^!_' tags)"
	@echo "Functions:  $$(grep -c '"\tf' tags)"
	@echo "Variables:  $$(grep -c '"\tv' tags)"
	@echo "Classes:    $$(grep -c '"\tc' tags)"
	@echo "Macros:     $$(grep -c '"\td' tags)"
	@echo "File size:  $$(ls -lh tags | awk '{print $$5}')"

# 使用
make tags              # 全量生成
make tags-incremental  # 增量更新
make clean-tags        # 清理
make full-index        # 生成完整索引
make tags-stats        # 查看统计

# .ctags.d/00-performance.ctags
# 大项目性能优化配置

# 排序（必须，编辑器二分查找依赖）
--sort=yes

# 字段精简
# 排除 pattern 字段（最大节省，但影响跳转精确度）
# 建议保留，否则需要行号字段补偿
--fields=+S+n-K

# 排除大量目录
--exclude=.git
--exclude=.svn
--exclude=node_modules
--exclude=bower_components
--exclude=vendor
--exclude=third_party
--exclude=external
--exclude=out
--exclude=build
--exclude=dist
--exclude=.next
--exclude=.nuxt
--exclude=.cache
--exclude=.venv
--exclude=venv
--exclude=__pycache__
--exclude=.tox
--exclude=.mypy_cache
--exclude=.pytest_cache
--exclude=coverage
--exclude=htmlcov
--exclude=*.min.js
--exclude=*.min.css
--exclude=*.map
--exclude=*.pyc
--exclude=*.pyo
--exclude=*.o
--exclude=*.a
--exclude=*.so
--exclude=*.dylib
--exclude=*.dll
--exclude=*.class

# .ctags.d/10-languages.ctags
# 只索引需要的语言
--languages=C,C++,Python,JavaScript,TypeScript,Go,Sh,Make

# .ctags.d/20-kinds.ctags
# 精简 kinds（减少标签数量）
# C/C++：只索引定义，不索引局部变量和头文件
--kinds-C=-l-h-x-z-D-L
--kinds-C++=-l-h-x-z-D-L

# Python：不索引局部变量
--kinds-Python=-l-v

# JavaScript：不索引变量
--kinds-JavaScript=-v-G

#!/bin/bash
# 使用 git ls-files 只索引 Git 跟踪的文件
# 优点：
# 1. 精确排除所有未跟踪文件和目录
# 2. 不需要维护冗长的 --exclude 列表
# 3. 比 --exclude 更快（减少文件系统遍历）

git ls-files | ctags -L - \
    --fields=+S+s+n \
    --extras=+q \
    --sort=yes \
    -f .tags

echo "Indexed $(git ls-files | wc -l) files"
echo "Generated $(grep -cv '^!_' .tags) tags"

# 生成标签文件
ctags -R .

# 检查大小
ls -lh tags

# 按 kind 统计标签数量
awk -F'\t' '
    /^!/ {next}  # 跳过伪标签
    {
        kind = $3
        gsub(/;.*/, "", kind)
        count[kind]++
    }
    END {
        for (k in count) print count[k], k
    }
' tags | sort -rn | head -20

# 典型输出：
# 15000 f    (函数)
# 8000  v    (变量)
# 5000  m    (成员)
# 3000  c    (类)
# 2000  d    (宏)
# ...

# 精简策略
# 1. 排除局部变量：--kinds-C=-l --kinds-Python=-l
# 2. 排除头文件：--kinds-C=-h
# 3. 禁用模式字段：--fields=-P（大幅减小，但影响精确跳转）

#!/bin/bash
# parallel_tags.sh - 并行生成语言特定标签

PROJECT_ROOT="."
TAGS_DIR=".tags.d"

mkdir -p "$TAGS_DIR"

# 定义语言和对应的文件扩展名
declare -A LANGS=(
    ["c"]="*.c,*.h"
    ["cpp"]="*.cpp,*.hpp,*.cc,*.cxx"
    ["python"]="*.py,*.pyw"
    ["javascript"]="*.js,*.jsx"
    ["typescript"]="*.ts,*.tsx"
    ["go"]="*.go"
    ["rust"]="*.rs"
    ["java"]="*.java"
)

# 并行生成
for lang in "${!LANGS[@]}"; do
    (
        exts="${LANGS[$lang]}"
        # 构建 find 命令
        find_args=""
        IFS=',' read -ra ext_array <<< "$exts"
        for ext in "${ext_array[@]}"; do
            if [ -n "$find_args" ]; then
                find_args="$find_args -o"
            fi
            find_args="$find_args -name '$ext'"
        done

        eval "find '$PROJECT_ROOT' -type f \\( $find_args \\)" | \
            grep -v '.git' | grep -v 'node_modules' | \
            ctags -L - --languages="$lang" \
                --fields=+S+s+n \
                --sort=yes \
                -f "$TAGS_DIR/tags.$lang" 2>/dev/null

        echo "Generated $TAGS_DIR/tags.$lang ($(wc -l < "$TAGS_DIR/tags.$lang") tags)"
    ) &
done

wait
echo "All tags generated."

# 合并标签文件
cat "$TAGS_DIR"/tags.* | grep -v '^!_' | sort -u > tags
echo "Merged into tags ($(grep -cv '^!_' tags) tags)"

# GitHub Actions - 完整的 CI 索引工作流
name: Code Index

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  index:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Install tools
      run: |
        sudo apt-get update
        sudo apt-get install -y universal-ctags

    - name: Generate tags
      run: |
        git ls-files | ctags -L - \
          --fields=+S+s+n \
          --extras=+q \
          --sort=yes \
          -f tags

    - name: Generate JSON index
      run: |
        git ls-files | ctags -L - \
          --output-format=json \
          --fields=+S+s+n \
          -f tags.json

    - name: Statistics
      run: |
        echo "=== Tags Statistics ==="
        echo "Total tags: $(grep -cv '^!_' tags)"
        echo "Functions: $(grep -c ';\t"f' tags || echo 0)"
        echo "Classes: $(grep -c ';\t"c' tags || echo 0)"
        echo "Tags file size: $(ls -lh tags | awk '{print $5}')"

    - name: Upload artifacts
      uses: actions/upload-artifact@v4
      with:
        name: code-index
        path: |
          tags
          tags.json

#!/bin/bash
# check_unused_exports.sh - 使用 Ctags 检查未使用的导出

# 1. 列出所有导出的函数
EXPORTS=$(ctags -f - --kinds-python=f | \
    grep -v '^!' | \
    awk -F'\t' '/\t__\t/ {next} {print $1}' | \
    sort -u)

echo "=== Checking unused exports ==="

for func in $EXPORTS; do
    # 统计引用次数（排除定义本身）
    refs=$(rg --word-regexp "$func" -g '*.py' --count-matches 2>/dev/null | \
        awk -F: '{sum+=$2} END {print sum+0}')

    if [ "$refs" -le 1 ]; then
        echo "UNUSED: $func (only $refs reference)"
        grep "^$func" tags
    fi
done

#!/bin/bash
# analyze_deps.sh - 使用 Ctags 分析文件依赖关系

analyze_file() {
    local file="$1"
    local symbols=$(ctags -f - "$file" | \
        grep -v '^!' | awk -F'\t' '{print $1}' | sort -u)

    echo "=== Dependencies of $file ==="
    echo "Exports: $(echo "$symbols" | wc -l) symbols"

    echo ""
    echo "Used by:"
    for symbol in $symbols; do
        users=$(rg --word-regexp "$symbol" -g '*.c' -g '*.h' -l 2>/dev/null | \
            grep -v "$file" | sort -u)
        if [ -n "$users" ]; then
            echo "  $symbol -> $users"
        fi
    done
}

analyze_file "$1"

-- init.lua - Neovim 配置：LSP + Ctags

-- Ctags 基本配置
vim.opt.tags = './.tags;,.tags'

-- LSP 配置
local lspconfig = require('lspconfig')

-- C/C++ - clangd
lspconfig.clangd.setup {
    cmd = {'clangd', '--background-index', '--clang-tidy'},
    capabilities = require('cmp_nvim_lsp').default_capabilities(),
}

-- Python - pyright
lspconfig.pyright.setup {}

-- TypeScript/JavaScript
lspconfig.ts_ls.setup {}

-- Go
lspconfig.gopls.setup {}

-- 智能标签跳转：先 LSP，后 Ctags
vim.keymap.set('n', 'gd', function()
    local clients = vim.lsp.buf_get_clients(0)
    if #clients > 0 then
        vim.lsp.buf.definition()
    else
        vim.cmd('normal! <C-]>')
    end
end, { desc = 'Go to definition (LSP or Ctags)' })

-- 符号搜索：结合 telescope 和 Ctags
local builtin = require('telescope.builtin')

-- LSP 符号搜索（当前文档）
vim.keymap.set('n', '<leader>ss', builtin.lsp_document_symbols,
    { desc = 'Search symbols (LSP)' })

-- Ctags 标签搜索（全局）
vim.keymap.set('n', '<leader>st', builtin.tags,
    { desc = 'Search tags (Ctags)' })

-- 使用 vim-gutentags 自动管理标签
vim.g.gutentags_ctags_tagfile = '.tags'
vim.g.gutentags_cache_dir = vim.fn.expand('~/.cache/nvim/tags')

vim.g.gutentags_ctags_extra_args = {
    '--fields=+S+s+n',
    '--extras=+q',
    '--sort=yes',
}

vim.g.gutentags_ctags_exclude = {
    '.git', 'node_modules', 'vendor', 'build', 'dist',
    '.venv', '__pycache__', '.next', '.nuxt',
}

-- 保存时自动更新标签
vim.g.gutentags_generate_on_new = 1
vim.g.gutentags_generate_on_missing = 1
vim.g.gutentags_generate_on_write = 1
vim.g.gutentags_generate_on_empty_buffer = 0

# 检查项目语言的 LSP 可用性
check_lsp() {
    local lang="$1"
    case "$lang" in
        c|cpp)    command -v clangd >/dev/null ;;
        python)   command -v pyright >/dev/null ;;
        go)       command -v gopls >/dev/null ;;
        rust)     command -v rust-analyzer >/dev/null ;;
        *)        return 1 ;;
    esac
}

# 自动决策：如果 LSP 可用，让 LSP 处理；否则用 Ctags
for lang in c python go rust; do
    if ! check_lsp "$lang"; then
        echo "LSP not available for $lang, Ctags will handle it"
    else
        echo "LSP available for $lang"
    fi
done

# .gitignore 中添加
tags
TAGS
.tags
TAGS.*
cscope.*
*.tags
.tags.d/

# 但项目级 .ctags 配置应该版本控制
# 保留：
.ctags
.ctags.d/

#!/bin/bash
# setup.sh - 项目初始化脚本

set -e

PROJECT_ROOT="$(cd "$(dirname "$0")" && pwd)"
cd "$PROJECT_ROOT"

echo "=== Setting up development environment ==="

# 1. 检查依赖
command -v ctags >/dev/null 2>&1 || {
    echo "Error: universal-ctags not found. Install it first."
    echo "  Ubuntu: sudo apt install universal-ctags"
    echo "  macOS:  brew install universal-ctags"
    exit 1
}

# 验证是 Universal Ctags
ctags --version 2>&1 | grep -q "Universal" || {
    echo "Warning: Exuberant Ctags detected. Universal Ctags is recommended."
}

# 2. 创建 .ctags.d 目录（如不存在）
mkdir -p .ctags.d

# 3. 生成初始标签
echo "Generating tags..."
git ls-files | ctags -L - \
    --fields=+S+s+n \
    --extras=+q \
    --sort=yes \
    -f .tags

echo "Generated $(grep -cv '^!_' .tags) tags"

# 4. 配置编辑器
if command -v vim >/dev/null 2>&1; then
    echo "Vim detected. Tags file: .tags"
    echo "Add to ~/.vimrc: set tags=./.tags;,.tags"
fi

echo "=== Setup complete ==="

# .ctags.d/00-team-default.ctags
# 团队共享的默认配置

# 基本设置
--sort=yes
--fields=+S+s+n
--extras=+q
--input-encoding=utf-8

# 团队约定的排除目录
--exclude=.git
--exclude=.svn
--exclude=node_modules
--exclude=vendor
--exclude=.venv
--exclude=__pycache__
--exclude=build
--exclude=dist
--exclude=out
--exclude=.cache

# 团队约定的语言
--languages=C,C++,Python,JavaScript,TypeScript,Go,Java,Sh,Make

# 团队约定的 kinds
--kinds-C=-l-h-x
--kinds-C++=-l-h-x
--kinds-Python=-l

# 1. 检查 tags 文件是否存在
ls -la tags

# 2. 检查 Vim 是否能找到
vim -c "echo tagfiles()"

# 3. 检查 tags 路径设置
vim -c "set tags?"

# 4. 检查符号是否在 tags 文件中
grep "^your_symbol" tags

# 5. 检查 tags 文件是否已排序
head -50 tags | awk -F'\t' '/^!/ {next} {print $1}' | sort -c

# 原因：标签文件过时，与源码不同步

# 解决方案 1：全量重建
ctags -R .

# 解决方案 2：删除旧文件后重建
rm -f tags && ctags -R .

# 解决方案 3：检查行号字段
ctags --fields=+n -f tags .

# 问题：ctags -R 运行缓慢

# 方案 1：减少语言范围
ctags -R --languages=C,C++,Python .

# 方案 2：排除大目录
ctags -R --exclude=node_modules --exclude=.git .

# 方案 3：使用 git ls-files
git ls-files | ctags -L -

# 方案 4：只索引修改的文件
git diff --name-only | ctags -L - --append=yes -f tags

# 方案 5：后台运行
nohup ctags -R . &

# 问题：同一符号有多个标签

# 原因 1：标签文件有重复（未排序或增量更新问题）
# 解决：删除并重新生成
rm tags && ctags -R --sort=yes .

# 原因 2：符号在多个文件中定义
# 解决：使用 :tselect 选择正确位置
# 或使用精确搜索
grep "^symbol_name\t.*\tf" tags  # 只搜索函数定义

# 原因 3：头文件和实现文件都有标签
# 解决：只索引实现文件
find . -name "*.c" -o -name "*.cpp" | ctags -L - -f tags

# ===== 生成标签 =====
ctags -R .                              # 递归生成
ctags -R --sort=yes --fields=+S .       # 推荐配置
git ls-files | ctags -L -               # 只索引 Git 文件
ctags -R --append=yes src/new.c         # 增量添加

# ===== 查看信息 =====
ctags --version                         # 版本
ctags --list-languages                  # 支持的语言
ctags --list-kinds=C                    # C 语言的 kinds
ctags --list-fields                     # 所有字段
ctags --list-features                   # 已编译的特性

# ===== 搜索标签 =====
grep "^symbol" tags                     # 精确搜索
grep ';"\tf' tags                       # 所有函数
grep 'class:MyClass' tags              # 类成员
ctags -x src/file.c                     # 交叉引用格式

# ===== JSON 输出 =====
ctags --output-format=json -f - .       # JSON 格式
ctags -f - . | jq 'select(.kind=="f")' # 用 jq 过滤