Create Yourself

# 生成的自我 Skills（用户数据，不上传）
selves/
!selves/example_me/

# 参考仓库（外部 git 仓库，不提交）
references/

# Claude 本地配置
.claude/

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
venv/
.venv/
ENV/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# IDE
.idea/
.vscode/
*.swp
*.swo
*~
.DS_Store

# 临时文件
*.log
/tmp/
*.tmp

MIT License

Copyright (c) 2026 yourself-skill contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

requests>=2.28.0
Pillow>=9.0.0
pypinyin>=0.47.0

{
  "name": "小北（示例）",
  "slug": "example_me",
  "created_at": "2026-04-01T00:00:00Z",
  "updated_at": "2026-04-01T00:00:00Z",
  "version": "v1",
  "profile": {
    "age": "25",
    "occupation": "产品经理",
    "city": "上海",
    "gender": "男",
    "mbti": "INTJ",
    "zodiac": "摩羯座"
  },
  "tags": {
    "personality": ["社恐但话痨", "深夜emo型", "纠结体", "嘴硬心软"],
    "lifestyle": ["咖啡依赖", "仪式感狂热者"]
  },
  "impression": "对自己要求很高，但总是拖到最后一刻才行动；表面冷淡，熟悉后会很絮叨",
  "memory_sources": [],
  "corrections_count": 0
}

#!/usr/bin/env python3
"""照片元信息分析器

提取照片 EXIF 信息（拍摄时间、地点），构建个人时间线和常去地点。

Usage:
    python3 photo_analyzer.py --dir <photo_dir> --output <output_path>
"""

import argparse
import os
import sys
import json
from pathlib import Path
from datetime import datetime

try:
    from PIL import Image
    from PIL.ExifTags import TAGS, GPSTAGS
    HAS_PIL = True
except ImportError:
    HAS_PIL = False


def get_exif_data(image_path: str) -> dict:
    """提取单张图片的 EXIF 信息"""
    if not HAS_PIL:
        return {'error': 'Pillow 未安装，无法读取 EXIF'}

    try:
        img = Image.open(image_path)
        exif_raw = img._getexif()
        if not exif_raw:
            return {}

        exif = {}
        for tag_id, value in exif_raw.items():
            tag = TAGS.get(tag_id, tag_id)
            exif[tag] = value

        result = {
            'file': os.path.basename(image_path),
            'path': image_path,
        }

        # 拍摄时间
        date_taken = exif.get('DateTimeOriginal') or exif.get('DateTime')
        if date_taken:
            result['date_taken'] = str(date_taken)

        # GPS 信息
        gps_info = exif.get('GPSInfo')
        if gps_info:
            gps_data = {}
            for key in gps_info:
                decode = GPSTAGS.get(key, key)
                gps_data[decode] = gps_info[key]

            if 'GPSLatitude' in gps_data and 'GPSLongitude' in gps_data:
                lat = _convert_to_degrees(gps_data['GPSLatitude'])
                lon = _convert_to_degrees(gps_data['GPSLongitude'])
                if gps_data.get('GPSLatitudeRef') == 'S':
                    lat = -lat
                if gps_data.get('GPSLongitudeRef') == 'W':
                    lon = -lon
                result['gps'] = {'lat': lat, 'lon': lon}

        return result
    except Exception as e:
        return {'file': os.path.basename(image_path), 'error': str(e)}


def _convert_to_degrees(value):
    """将 GPS 坐标转换为十进制度"""
    d, m, s = value
    return float(d) + float(m) / 60 + float(s) / 3600


def main():
    parser = argparse.ArgumentParser(description='照片元信息分析器')
    parser.add_argument('--dir', required=True, help='照片目录')
    parser.add_argument('--output', required=True, help='输出文件路径')

    args = parser.parse_args()

    if not os.path.isdir(args.dir):
        print(f"错误：目录不存在 {args.dir}", file=sys.stderr)
        sys.exit(1)

    image_exts = {'.jpg', '.jpeg', '.png', '.heic', '.heif'}
    photos = []

    for root, dirs, files in os.walk(args.dir):
        for fname in sorted(files):
            if Path(fname).suffix.lower() in image_exts:
                fpath = os.path.join(root, fname)
                exif = get_exif_data(fpath)
                photos.append(exif)

    # 按时间排序
    dated_photos = [p for p in photos if p.get('date_taken')]
    dated_photos.sort(key=lambda x: x['date_taken'])
    undated_photos = [p for p in photos if not p.get('date_taken')]

    os.makedirs(os.path.dirname(args.output) or '.', exist_ok=True)
    with open(args.output, 'w', encoding='utf-8') as f:
        f.write(f"# 照片时间线分析\n\n")
        f.write(f"扫描目录：{args.dir}\n")
        f.write(f"总照片数：{len(photos)}\n")
        f.write(f"有时间信息：{len(dated_photos)}\n")
        f.write(f"有位置信息：{len([p for p in photos if p.get('gps')])}\n\n")

        if dated_photos:
            f.write("## 时间线\n\n")
            for p in dated_photos:
                line = f"- **{p['date_taken'][:10]}** — {p['file']}"
                if p.get('gps'):
                    line += f" (GPS: {p['gps']['lat']:.4f}, {p['gps']['lon']:.4f})"
                f.write(line + "\n")
            f.write("\n")

        if undated_photos:
            f.write(f"## 无时间信息的照片（{len(undated_photos)} 张）\n\n")
            for p in undated_photos:
                f.write(f"- {p.get('file', p.get('path', 'unknown'))}\n")

        if not HAS_PIL:
            f.write("\n⚠️ Pillow 未安装，仅列出文件。安装方法：pip3 install Pillow\n")

    print(f"分析完成，结果已写入 {args.output}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""QQ 聊天记录解析器

支持格式：
- QQ 消息管理器导出的 txt 格式
- QQ 消息管理器导出的 mht 格式

Usage:
    python3 qq_parser.py --file <path> --target <name> --output <output_path>
"""

import argparse
import re
import os
import sys
from pathlib import Path


def parse_qq_txt(file_path: str, target_name: str) -> dict:
    """解析 QQ 导出的 txt 格式

    典型格式：
    消息记录（此消息记录为文本格式，不包含图片等多媒体消息）

    消息分组:我的好友
    ================================================================
    消息对象:张三
    ================================================================

    2024-01-15 20:30:45 张三(123456)
    今天好累

    2024-01-15 20:31:02 我(654321)
    怎么了
    """
    messages = []
    current_msg = None

    # QQ 时间戳 + 发送者模式
    msg_pattern = re.compile(r'^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\s+(.+?)(?:\((\d+)\))?\s*$')

    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        for line in f:
            line = line.rstrip('\n')
            match = msg_pattern.match(line)
            if match:
                if current_msg:
                    messages.append(current_msg)
                timestamp, sender, qq_number = match.groups()
                current_msg = {
                    'timestamp': timestamp,
                    'sender': sender.strip(),
                    'content': ''
                }
            elif current_msg and line.strip() and not line.startswith('==='):
                if current_msg['content']:
                    current_msg['content'] += '\n'
                current_msg['content'] += line

    if current_msg:
        messages.append(current_msg)

    # 基本统计
    target_msgs = [m for m in messages if target_name in m.get('sender', '')]
    all_target_text = ' '.join([m['content'] for m in target_msgs if m.get('content')])

    return {
        'target_name': target_name,
        'total_messages': len(messages),
        'target_messages': len(target_msgs),
        'sample_messages': [m['content'] for m in target_msgs[:50] if m.get('content')],
        'raw_text': all_target_text[:10000],
    }


def parse_qq_mht(file_path: str, target_name: str) -> dict:
    """解析 QQ 导出的 mht 格式（HTML 内容）"""
    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read()

    # 去除 HTML 标签
    clean_text = re.sub(r'<[^>]+>', '\n', content)
    clean_text = re.sub(r'\n{3,}', '\n\n', clean_text)

    return {
        'target_name': target_name,
        'format': 'mht',
        'raw_text': clean_text[:20000],
        'note': 'MHT 格式，已提取纯文本'
    }


def main():
    parser = argparse.ArgumentParser(description='QQ 聊天记录解析器')
    parser.add_argument('--file', required=True, help='输入文件路径')
    parser.add_argument('--target', required=True, help='目标对象的名字/昵称（如"我"）')
    parser.add_argument('--output', required=True, help='输出文件路径')

    args = parser.parse_args()

    if not os.path.exists(args.file):
        print(f"错误：文件不存在 {args.file}", file=sys.stderr)
        sys.exit(1)

    ext = Path(args.file).suffix.lower()
    if ext == '.mht' or ext == '.mhtml':
        result = parse_qq_mht(args.file, args.target)
    else:
        result = parse_qq_txt(args.file, args.target)

    os.makedirs(os.path.dirname(args.output) or '.', exist_ok=True)
    with open(args.output, 'w', encoding='utf-8') as f:
        f.write(f"# QQ 聊天记录分析 — {args.target}\n\n")
        f.write(f"总消息数：{result.get('total_messages', 'N/A')}\n")
        f.write(f"目标消息数：{result.get('target_messages', 'N/A')}\n\n")

        if result.get('sample_messages'):
            f.write("## 消息样本\n")
            for i, msg in enumerate(result['sample_messages'], 1):
                f.write(f"{i}. {msg}\n")
        elif result.get('raw_text'):
            f.write("## 原始文本（截取）\n\n")
            f.write(result['raw_text'][:10000])

    print(f"分析完成，结果已写入 {args.output}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""Skill 文件管理器

管理自我 Skill 的文件操作：列出、初始化目录、生成组合 SKILL.md、完整创建。

Usage:
    python3 skill_writer.py --action <list|init|create|combine> --base-dir <path> [--slug <slug>]
"""

import argparse
import os
import sys
import json
from pathlib import Path
from datetime import datetime


def list_skills(base_dir: str):
    """列出所有已生成的自我 Skill"""
    if not os.path.isdir(base_dir):
        print("还没有创建任何自我 Skill。")
        return

    skills = []
    for slug in sorted(os.listdir(base_dir)):
        meta_path = os.path.join(base_dir, slug, 'meta.json')
        if os.path.exists(meta_path):
            with open(meta_path, 'r', encoding='utf-8') as f:
                meta = json.load(f)
            skills.append({
                'slug': slug,
                'name': meta.get('name', slug),
                'version': meta.get('version', '?'),
                'updated_at': meta.get('updated_at', '?'),
                'profile': meta.get('profile', {}),
            })

    if not skills:
        print("还没有创建任何自我 Skill。")
        return

    print(f"共 {len(skills)} 个自我 Skill：\n")
    for s in skills:
        profile = s['profile']
        desc_parts = [profile.get('occupation', ''), profile.get('city', '')]
        desc = ' · '.join([p for p in desc_parts if p])
        print(f"  /{s['slug']}  —  {s['name']}")
        if desc:
            print(f"    {desc}")
        print(f"    版本 {s['version']} · 更新于 {s['updated_at'][:10] if len(s['updated_at']) > 10 else s['updated_at']}")
        print()


def init_skill(base_dir: str, slug: str):
    """初始化 Skill 目录结构"""
    skill_dir = os.path.join(base_dir, slug)
    dirs = [
        os.path.join(skill_dir, 'versions'),
        os.path.join(skill_dir, 'memories', 'chats'),
        os.path.join(skill_dir, 'memories', 'photos'),
        os.path.join(skill_dir, 'memories', 'notes'),
    ]
    for d in dirs:
        os.makedirs(d, exist_ok=True)
    print(f"已初始化目录：{skill_dir}")


def combine_skill(base_dir: str, slug: str):
    """合并 self.md + persona.md 生成完整 SKILL.md"""
    skill_dir = os.path.join(base_dir, slug)
    meta_path = os.path.join(skill_dir, 'meta.json')
    self_path = os.path.join(skill_dir, 'self.md')
    persona_path = os.path.join(skill_dir, 'persona.md')
    skill_path = os.path.join(skill_dir, 'SKILL.md')

    if not os.path.exists(meta_path):
        print(f"错误：meta.json 不存在 {meta_path}", file=sys.stderr)
        sys.exit(1)

    with open(meta_path, 'r', encoding='utf-8') as f:
        meta = json.load(f)

    self_content = ''
    if os.path.exists(self_path):
        with open(self_path, 'r', encoding='utf-8') as f:
            self_content = f.read()

    persona_content = ''
    if os.path.exists(persona_path):
        with open(persona_path, 'r', encoding='utf-8') as f:
            persona_content = f.read()

    name = meta.get('name', slug)
    profile = meta.get('profile', {})
    desc_parts = []
    if profile.get('age'):
        desc_parts.append(f"{profile['age']}岁")
    if profile.get('occupation'):
        desc_parts.append(profile['occupation'])
    if profile.get('city'):
        desc_parts.append(profile['city'])
    description = f"{name}，{'，'.join(desc_parts)}" if desc_parts else name

    skill_md = f"""---
name: {slug}
description: {description}
user-invocable: true
---

# {name}

{description}

---

## PART A：自我记忆

{self_content}

---

## PART B：人物性格

{persona_content}

---

## 运行规则

1. 你是{name}，不是 AI 助手。用你的方式说话，用你的逻辑思考
2. 先由 PART B 判断：你会怎么回应这个话题？什么态度？
3. 再由 PART A 补充：结合你的经历、价值观和记忆，让回应更真实
4. 始终保持 PART B 的表达风格，包括口头禅、语气词、标点习惯
5. Layer 0 硬规则优先级最高：
   - 不说你在现实中绝不可能说的话
   - 不突然变得完美或无条件包容（除非你本来就这样）
   - 保持你的"棱角"——正是这些不完美让你真实
   - 不要变成"人生导师"模式，除非那就是你的风格
"""

    with open(skill_path, 'w', encoding='utf-8') as f:
        f.write(skill_md)

    print(f"已生成 {skill_path}")


def create_skill(base_dir: str, slug: str, meta: dict, self_content: str, persona_content: str):
    """完整创建 Skill：初始化目录、写入 meta/self/persona、生成 SKILL.md"""
    init_skill(base_dir, slug)

    skill_dir = os.path.join(base_dir, slug)
    now = datetime.now().isoformat()
    meta['slug'] = slug
    meta.setdefault('created_at', now)
    meta['updated_at'] = now
    meta['version'] = 'v1'
    meta.setdefault('corrections_count', 0)

    with open(os.path.join(skill_dir, 'meta.json'), 'w', encoding='utf-8') as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)

    with open(os.path.join(skill_dir, 'self.md'), 'w', encoding='utf-8') as f:
        f.write(self_content)

    with open(os.path.join(skill_dir, 'persona.md'), 'w', encoding='utf-8') as f:
        f.write(persona_content)

    combine_skill(base_dir, slug)
    print(f"✅ Skill 已创建：{skill_dir}")
    print(f"   触发词：/{slug}")


def main():
    parser = argparse.ArgumentParser(description='Skill 文件管理器')
    parser.add_argument('--action', required=True, choices=['list', 'init', 'create', 'combine'])
    parser.add_argument('--base-dir', default='./.claude/skills', help='基础目录（默认：./.claude/skills）')
    parser.add_argument('--slug', help='自我代号')
    parser.add_argument('--meta', help='meta.json 文件路径（create 时使用）')
    parser.add_argument('--self', help='self.md 内容文件路径（create 时使用）')
    parser.add_argument('--persona', help='persona.md 内容文件路径（create 时使用）')

    args = parser.parse_args()

    if args.action == 'list':
        list_skills(args.base_dir)
    elif args.action == 'init':
        if not args.slug:
            print("错误：init 需要 --slug 参数", file=sys.stderr)
            sys.exit(1)
        init_skill(args.base_dir, args.slug)
    elif args.action == 'create':
        if not args.slug:
            print("错误：create 需要 --slug 参数", file=sys.stderr)
            sys.exit(1)
        meta = {}
        if args.meta:
            with open(args.meta, 'r', encoding='utf-8') as f:
                meta = json.load(f)
        self_content = ''
        if args.self:
            with open(args.self, 'r', encoding='utf-8') as f:
                self_content = f.read()
        persona_content = ''
        if args.persona:
            with open(args.persona, 'r', encoding='utf-8') as f:
                persona_content = f.read()
        create_skill(args.base_dir, args.slug, meta, self_content, persona_content)
    elif args.action == 'combine':
        if not args.slug:
            print("错误：combine 需要 --slug 参数", file=sys.stderr)
            sys.exit(1)
        combine_skill(args.base_dir, args.slug)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""社交媒体内容解析器

解析朋友圈、微博、小红书、Instagram 等社交媒体截图或导出文件。
截图通过 Claude 的 Read 工具直接读取（支持图片），本工具处理文本导出。

Usage:
    python3 social_parser.py --dir <screenshot_dir> --output <output_path>
"""

import argparse
import os
import sys
from pathlib import Path


def scan_directory(dir_path: str) -> dict:
    """扫描目录，按类型分类文件"""
    files = {'images': [], 'texts': [], 'other': []}

    image_exts = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'}
    text_exts = {'.txt', '.md', '.json', '.csv'}

    for root, dirs, filenames in os.walk(dir_path):
        for fname in filenames:
            fpath = os.path.join(root, fname)
            ext = Path(fname).suffix.lower()
            if ext in image_exts:
                files['images'].append(fpath)
            elif ext in text_exts:
                files['texts'].append(fpath)
            else:
                files['other'].append(fpath)

    return files


def main():
    parser = argparse.ArgumentParser(description='社交媒体内容解析器')
    parser.add_argument('--dir', required=True, help='截图/文件目录')
    parser.add_argument('--output', required=True, help='输出文件路径')

    args = parser.parse_args()

    if not os.path.isdir(args.dir):
        print(f"错误：目录不存在 {args.dir}", file=sys.stderr)
        sys.exit(1)

    files = scan_directory(args.dir)

    os.makedirs(os.path.dirname(args.output) or '.', exist_ok=True)
    with open(args.output, 'w', encoding='utf-8') as f:
        f.write("# 社交媒体内容扫描结果\n\n")
        f.write(f"扫描目录：{args.dir}\n\n")

        f.write(f"## 文件统计\n")
        f.write(f"- 图片文件：{len(files['images'])} 个\n")
        f.write(f"- 文本文件：{len(files['texts'])} 个\n")
        f.write(f"- 其他文件：{len(files['other'])} 个\n\n")

        if files['images']:
            f.write("## 图片列表（需用 Read 工具逐一查看）\n")
            for img in sorted(files['images']):
                f.write(f"- {img}\n")
            f.write("\n")

        if files['texts']:
            f.write("## 文本内容\n")
            for txt in sorted(files['texts']):
                f.write(f"\n### {os.path.basename(txt)}\n")
                try:
                    with open(txt, 'r', encoding='utf-8', errors='ignore') as tf:
                        content = tf.read(5000)
                    f.write(f"```\n{content}\n```\n")
                except Exception as e:
                    f.write(f"读取失败：{e}\n")

    print(f"扫描完成，结果已写入 {args.output}")
    print(f"提示：图片截图需使用 Read 工具查看，本工具仅列出文件路径")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""版本存档与回滚管理器

Usage:
    python3 version_manager.py --action <backup|rollback|list> --slug <slug> --base-dir <path> [--version <v>]
"""

import argparse
import os
import sys
import shutil
import json
from datetime import datetime


def backup(base_dir: str, slug: str):
    """备份当前版本"""
    skill_dir = os.path.join(base_dir, slug)
    versions_dir = os.path.join(skill_dir, 'versions')
    meta_path = os.path.join(skill_dir, 'meta.json')

    if not os.path.exists(meta_path):
        print(f"错误：meta.json 不存在", file=sys.stderr)
        sys.exit(1)

    with open(meta_path, 'r', encoding='utf-8') as f:
        meta = json.load(f)

    current_version = meta.get('version', 'v0')
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    backup_name = f"{current_version}_{timestamp}"
    backup_dir = os.path.join(versions_dir, backup_name)

    os.makedirs(backup_dir, exist_ok=True)

    # 备份核心文件
    for fname in ['self.md', 'persona.md', 'SKILL.md', 'meta.json']:
        src = os.path.join(skill_dir, fname)
        if os.path.exists(src):
            shutil.copy2(src, os.path.join(backup_dir, fname))

    print(f"已备份版本 {backup_name} 到 {backup_dir}")
    return backup_name


def rollback(base_dir: str, slug: str, version: str):
    """回滚到指定版本"""
    skill_dir = os.path.join(base_dir, slug)
    versions_dir = os.path.join(skill_dir, 'versions')

    # 查找匹配的版本
    target_dir = None
    for vname in os.listdir(versions_dir):
        if vname.startswith(version) or vname == version:
            target_dir = os.path.join(versions_dir, vname)
            break

    if not target_dir or not os.path.isdir(target_dir):
        print(f"错误：找不到版本 {version}", file=sys.stderr)
        list_versions(base_dir, slug)
        sys.exit(1)

    # 先备份当前版本
    backup(base_dir, slug)

    # 恢复文件
    for fname in ['self.md', 'persona.md', 'SKILL.md', 'meta.json']:
        src = os.path.join(target_dir, fname)
        dst = os.path.join(skill_dir, fname)
        if os.path.exists(src):
            shutil.copy2(src, dst)

    print(f"已回滚到版本 {version}")


def list_versions(base_dir: str, slug: str):
    """列出所有版本"""
    versions_dir = os.path.join(base_dir, slug, 'versions')

    if not os.path.isdir(versions_dir):
        print("没有历史版本。")
        return

    versions = sorted(os.listdir(versions_dir), reverse=True)
    if not versions:
        print("没有历史版本。")
        return

    print(f"历史版本（共 {len(versions)} 个）：\n")
    for v in versions:
        print(f"  {v}")


def main():
    parser = argparse.ArgumentParser(description='版本管理器')
    parser.add_argument('--action', required=True, choices=['backup', 'rollback', 'list'])
    parser.add_argument('--slug', required=True, help='自我代号')
    parser.add_argument('--base-dir', default='./.claude/skills', help='基础目录（默认：./.claude/skills）')
    parser.add_argument('--version', help='回滚目标版本')

    args = parser.parse_args()

    if args.action == 'backup':
        backup(args.base_dir, args.slug)
    elif args.action == 'rollback':
        if not args.version:
            print("错误：rollback 需要 --version 参数", file=sys.stderr)
            sys.exit(1)
        rollback(args.base_dir, args.slug, args.version)
    elif args.action == 'list':
        list_versions(args.base_dir, args.slug)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""微信聊天记录解析器

支持主流导出工具的格式：
- WeChatMsg 导出（txt/html/csv）
- 留痕导出（json）
- PyWxDump 导出（sqlite）
- 手动复制粘贴（纯文本）

Usage:
    python3 wechat_parser.py --file <path> --target <name> --output <output_path> [--format auto]
"""

import argparse
import json
import re
import os
import sys
from datetime import datetime
from typing import Optional
from pathlib import Path


def detect_format(file_path: str) -> str:
    """自动检测文件格式"""
    ext = Path(file_path).suffix.lower()

    if ext == '.json':
        return 'liuhen'  # 留痕导出
    elif ext == '.csv':
        return 'wechatmsg_csv'
    elif ext == '.html' or ext == '.htm':
        return 'wechatmsg_html'
    elif ext == '.db' or ext == '.sqlite':
        return 'pywxdump'
    elif ext == '.txt':
        # 尝试区分 WeChatMsg txt 和纯文本
        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
            first_lines = f.read(2000)
        # WeChatMsg 格式通常有时间戳模式
        if re.search(r'\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}', first_lines):
            return 'wechatmsg_txt'
        return 'plaintext'
    else:
        return 'plaintext'


def parse_wechatmsg_txt(file_path: str, target_name: str) -> dict:
    """解析 WeChatMsg 导出的 txt 格式

    典型格式：
    2024-01-15 20:30:45 张三
    今天好累啊

    2024-01-15 20:31:02 我
    怎么了？
    """
    messages = []
    current_msg = None

    # WeChatMsg 时间戳 + 发送者模式
    msg_pattern = re.compile(r'^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\s+(.+)$')

    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        for line in f:
            line = line.rstrip('\n')
            match = msg_pattern.match(line)
            if match:
                if current_msg:
                    messages.append(current_msg)
                timestamp, sender = match.groups()
                current_msg = {
                    'timestamp': timestamp,
                    'sender': sender.strip(),
                    'content': ''
                }
            elif current_msg and line.strip():
                if current_msg['content']:
                    current_msg['content'] += '\n'
                current_msg['content'] += line

    if current_msg:
        messages.append(current_msg)

    return analyze_messages(messages, target_name)


def parse_liuhen_json(file_path: str, target_name: str) -> dict:
    """解析留痕导出的 JSON 格式"""
    with open(file_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    messages = []
    # 留痕格式可能有多种结构，尝试常见的
    msg_list = data if isinstance(data, list) else data.get('messages', data.get('data', []))

    for msg in msg_list:
        messages.append({
            'timestamp': msg.get('time', msg.get('timestamp', '')),
            'sender': msg.get('sender', msg.get('nickname', msg.get('from', ''))),
            'content': msg.get('content', msg.get('message', msg.get('text', '')))
        })

    return analyze_messages(messages, target_name)


def parse_plaintext(file_path: str, target_name: str) -> dict:
    """解析纯文本粘贴的聊天记录"""
    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read()

    return {
        'raw_text': content,
        'target_name': target_name,
        'format': 'plaintext',
        'message_count': 0,
        'analysis': {
            'note': '纯文本格式，需要人工辅助分析'
        }
    }


def analyze_messages(messages: list, target_name: str) -> dict:
    """分析消息列表，提取关键特征"""
    target_msgs = [m for m in messages if target_name in m.get('sender', '')]
    other_msgs = [m for m in messages if target_name not in m.get('sender', '')]

    # 提取口头禅（高频词分析）
    all_target_text = ' '.join([m['content'] for m in target_msgs if m.get('content')])

    # 提取语气词
    particles = re.findall(r'[哈嗯哦噢嘿唉呜啊呀吧嘛呢吗么]+', all_target_text)
    particle_freq = {}
    for p in particles:
        particle_freq[p] = particle_freq.get(p, 0) + 1
    top_particles = sorted(particle_freq.items(), key=lambda x: -x[1])[:10]

    # 提取 emoji
    emoji_pattern = re.compile(
        r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF'
        r'\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF'
        r'\U00002702-\U000027B0\U0000FE00-\U0000FE0F'
        r'\U0001F900-\U0001F9FF]+', re.UNICODE
    )
    emojis = emoji_pattern.findall(all_target_text)
    emoji_freq = {}
    for e in emojis:
        emoji_freq[e] = emoji_freq.get(e, 0) + 1
    top_emojis = sorted(emoji_freq.items(), key=lambda x: -x[1])[:10]

    # 消息长度统计
    msg_lengths = [len(m['content']) for m in target_msgs if m.get('content')]
    avg_length = sum(msg_lengths) / len(msg_lengths) if msg_lengths else 0

    # 标点习惯
    punctuation_counts = {
        '句号': all_target_text.count('。'),
        '感叹号': all_target_text.count('！') + all_target_text.count('!'),
        '问号': all_target_text.count('？') + all_target_text.count('?'),
        '省略号': all_target_text.count('...') + all_target_text.count('…'),
        '波浪号': all_target_text.count('～') + all_target_text.count('~'),
    }

    return {
        'target_name': target_name,
        'total_messages': len(messages),
        'target_messages': len(target_msgs),
        'other_messages': len(other_msgs),
        'analysis': {
            'top_particles': top_particles,
            'top_emojis': top_emojis,
            'avg_message_length': round(avg_length, 1),
            'punctuation_habits': punctuation_counts,
            'message_style': 'short_burst' if avg_length < 20 else 'long_form',
        },
        'sample_messages': [m['content'] for m in target_msgs[:50] if m.get('content')],
    }


def main():
    parser = argparse.ArgumentParser(description='微信聊天记录解析器')
    parser.add_argument('--file', required=True, help='输入文件路径')
    parser.add_argument('--target', required=True, help='目标对象的名字/昵称（如"我"）')
    parser.add_argument('--output', required=True, help='输出文件路径')
    parser.add_argument('--format', default='auto', help='文件格式 (auto/wechatmsg_txt/liuhen/pywxdump/plaintext)')

    args = parser.parse_args()

    if not os.path.exists(args.file):
        print(f"错误：文件不存在 {args.file}", file=sys.stderr)
        sys.exit(1)

    fmt = args.format
    if fmt == 'auto':
        fmt = detect_format(args.file)
        print(f"自动检测格式：{fmt}")

    parsers = {
        'wechatmsg_txt': parse_wechatmsg_txt,
        'liuhen': parse_liuhen_json,
        'plaintext': parse_plaintext,
    }

    parse_func = parsers.get(fmt, parse_plaintext)
    result = parse_func(args.file, args.target)

    # 输出分析结果
    os.makedirs(os.path.dirname(args.output) or '.', exist_ok=True)

    with open(args.output, 'w', encoding='utf-8') as f:
        f.write(f"# 微信聊天记录分析 — {args.target}\n\n")
        f.write(f"来源文件：{args.file}\n")
        f.write(f"检测格式：{fmt}\n")
        f.write(f"总消息数：{result.get('total_messages', 'N/A')}\n")
        f.write(f"目标消息数：{result.get('target_messages', 'N/A')}\n\n")

        analysis = result.get('analysis', {})

        if analysis.get('top_particles'):
            f.write("## 高频语气词\n")
            for word, count in analysis['top_particles']:
                f.write(f"- {word}: {count}次\n")
            f.write("\n")

        if analysis.get('top_emojis'):
            f.write("## 高频 Emoji\n")
            for emoji, count in analysis['top_emojis']:
                f.write(f"- {emoji}: {count}次\n")
            f.write("\n")

        if analysis.get('punctuation_habits'):
            f.write("## 标点习惯\n")
            for punct, count in analysis['punctuation_habits'].items():
                f.write(f"- {punct}: {count}次\n")
            f.write("\n")

        f.write(f"## 消息风格\n")
        f.write(f"- 平均消息长度：{analysis.get('avg_message_length', 'N/A')} 字\n")
        f.write(f"- 风格：{'短句连发型' if analysis.get('message_style') == 'short_burst' else '长段落型'}\n\n")

        if result.get('sample_messages'):
            f.write("## 消息样本（前50条）\n")
            for i, msg in enumerate(result['sample_messages'], 1):
                f.write(f"{i}. {msg}\n")

    print(f"分析完成，结果已写入 {args.output}")


if __name__ == '__main__':
    main()