Przeniesienie do Claude — krok po kroku

#!/usr/bin/env python3
"""
Zamienia eksport danych z ChatGPT albo z Claude na osobne pliki Markdown,
po jednym na rozmowe. Format eksportu rozpoznaje sam.

Uzycie:
    python convert_chats.py "C:\\sciezka\\do\\rozpakowanego\\eksportu"
    python convert_chats.py "folder eksportu" "folder na wynik"

Bez argumentow skrypt szuka eksportu w folderze, w ktorym sam lezy.
Wynik: podfolder "md" w folderze eksportu (albo folder podany jako drugi argument).
Z eksportu Claude powstaja dodatkowo: _pamiec.md (pamiec) i _projekty/ (instrukcje
i pliki wiedzy projektow). Plikow zrodlowych skrypt nie zmienia i nie laczy sie z siecia.

Wersja pierwotna (ChatGPT): zespol IT, u ktorego skrypt powstal.
Adaptacja i obsluga eksportu Claude: Silabris.
"""
import json
import re
import sys
from datetime import datetime, timezone
from pathlib import Path

UNSAFE_CHARS = re.compile(r'[/\\:*?"<>|]')
WHITESPACE = re.compile(r"\s+")
MAX_NAME = 80


# ---------- wspolne ----------

def slugify(title):
    slug = WHITESPACE.sub("_", str(title).strip())
    slug = UNSAFE_CHARS.sub("_", slug)
    slug = slug.lower()[:MAX_NAME].rstrip("._ ")
    return slug or "rozmowa"


def unique_path(out_dir, slug, used_counts, suffix=".md"):
    count = used_counts.get(slug, 0)
    used_counts[slug] = count + 1
    if count == 0:
        return out_dir / f"{slug}{suffix}", False
    return out_dir / f"{slug}_({count}){suffix}", True


def render(front_matter, title, messages):
    lines = ["---"] + [f"{k}: {v}" for k, v in front_matter] + ["---", "", f"# {title}", ""]
    for msg in messages:
        lines += [f"**{msg['author']}:**", "", msg["text"], "", "---"]
    return "\n".join(lines) + "\n"


def detect_format(conversation):
    if not isinstance(conversation, dict):
        return None
    if "mapping" in conversation:
        return "chatgpt"
    if "chat_messages" in conversation:
        return "claude"
    return None


# ---------- ChatGPT ----------

def iso(ts):
    if ts is None:
        return ""
    try:
        return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
    except (TypeError, ValueError, OSError):
        return ""


def chatgpt_messages(conversation):
    """Idzie po conversation['mapping'] od current_node do korzenia,
    zbiera wiadomosci tekstowe i odwraca je do kolejnosci chronologicznej."""
    messages = []
    mapping = conversation.get("mapping") or {}
    current_node = conversation.get("current_node")

    while current_node is not None:
        node = mapping.get(current_node)
        if node is None:
            break

        message = node.get("message")
        if message:
            content = message.get("content") or {}
            parts = content.get("parts") or []
            author = message.get("author") or {}
            role = author.get("role")
            metadata = message.get("metadata") or {}

            is_text = (
                content.get("content_type") == "text"
                and len(parts) > 0
                and isinstance(parts[0], str)
                and len(parts[0]) > 0
                and (role != "system" or metadata.get("is_user_system_message"))
            )
            if is_text:
                if role == "assistant":
                    author_label = "ChatGPT"
                elif role == "system" and metadata.get("is_user_system_message"):
                    author_label = "Custom user info"
                else:
                    author_label = role
                messages.append({"author": author_label, "text": parts[0]})

        current_node = node.get("parent")

    messages.reverse()
    return messages


def chatgpt_conversation(conversation, number):
    if not conversation.get("mapping") or not conversation.get("current_node"):
        return None
    title = conversation.get("title") or f"conversation_{number}"
    front_matter = [
        ("source", "chatgpt"),
        ("conversation_id", conversation.get("id") or conversation.get("conversation_id") or ""),
        ("created", iso(conversation.get("create_time"))),
        ("updated", iso(conversation.get("update_time"))),
        ("model", conversation.get("default_model_slug") or ""),
        ("is_starred", bool(conversation.get("is_starred"))),
    ]
    return title, render(front_matter, title, chatgpt_messages(conversation))


# ---------- Claude ----------

def claude_message_text(message):
    parts = []
    for block in message.get("content") or []:
        if isinstance(block, dict) and block.get("type") == "text" and block.get("text"):
            parts.append(block["text"])
    text = "\n\n".join(parts) or (message.get("text") or "")
    names = [a.get("file_name") for a in (message.get("attachments") or []) if isinstance(a, dict)]
    names += [f.get("file_name") for f in (message.get("files") or []) if isinstance(f, dict)]
    names = [n for n in names if n]
    if names:
        text = (text + "\n\n" if text else "") + "Zalaczniki: " + ", ".join(names)
    return text


def claude_conversation(conversation, number):
    raw = conversation.get("chat_messages") or []
    messages = []
    for message in raw:
        if not isinstance(message, dict):
            continue
        text = claude_message_text(message)
        if not text:
            continue
        author = "Claude" if message.get("sender") == "assistant" else "Uzytkownik"
        messages.append({"author": author, "text": text})
    if not messages:
        return None
    created = conversation.get("created_at") or ""
    title = conversation.get("name") or f"rozmowa bez tytulu {created[:10] or number}"
    front_matter = [
        ("source", "claude"),
        ("conversation_id", conversation.get("uuid") or ""),
        ("created", created),
        ("updated", conversation.get("updated_at") or ""),
    ]
    return title, render(front_matter, title, messages)


def claude_memory(src_dir, out_dir):
    path = src_dir / "memories.json"
    if not path.is_file():
        return False
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return False
    entries = data if isinstance(data, list) else [data]
    lines = ["# Pamiec z eksportu Claude", ""]
    found = False
    for entry in entries:
        if not isinstance(entry, dict):
            continue
        general = entry.get("conversations_memory")
        if general:
            lines += ["## Pamiec ogolna", "", str(general), ""]
            found = True
        projects = entry.get("project_memories") or {}
        if isinstance(projects, dict):
            for key, value in projects.items():
                if value:
                    lines += [f"## Pamiec projektu {key}", "", str(value), ""]
                    found = True
    if found:
        (out_dir / "_pamiec.md").write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
    return found


def claude_projects(src_dir, out_dir):
    folder = src_dir / "projects"
    if not folder.is_dir():
        return 0
    target = out_dir / "_projekty"
    used = {}
    count = 0
    for path in sorted(folder.glob("*.json")):
        try:
            project = json.loads(path.read_text(encoding="utf-8"))
        except (OSError, ValueError):
            continue
        if not isinstance(project, dict):
            continue
        name = project.get("name") or path.stem
        slug = slugify(name)
        lines = [
            "---",
            "source: claude",
            f"project_id: {project.get('uuid') or ''}",
            f"created: {project.get('created_at') or ''}",
            f"updated: {project.get('updated_at') or ''}",
            "---",
            "",
            f"# {name}",
            "",
        ]
        if project.get("description"):
            lines += ["## Opis", "", str(project["description"]), ""]
        if project.get("prompt_template"):
            lines += ["## Instrukcje projektu", "", str(project["prompt_template"]), ""]
        docs = [d for d in (project.get("docs") or []) if isinstance(d, dict)]
        if docs:
            lines += ["## Pliki wiedzy", ""]
        target.mkdir(parents=True, exist_ok=True)
        project_path, _ = unique_path(target, slug, used)
        docs_dir = project_path.with_suffix("")
        doc_used = {}
        for doc in docs:
            doc_name = doc.get("filename") or doc.get("file_name") or "plik"
            lines.append(f"- {doc_name}")
            content = doc.get("content")
            if isinstance(content, str) and content:
                docs_dir.mkdir(parents=True, exist_ok=True)
                doc_path, _ = unique_path(docs_dir, slugify(doc_name), doc_used, suffix=".txt")
                doc_path.write_text(content, encoding="utf-8", newline="\n")
        project_path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
        count += 1
    return count


# ---------- program ----------

def find_sources(src_dir):
    files = sorted(src_dir.glob("conversations-*.json"))
    single = src_dir / "conversations.json"
    if single.is_file():
        files.insert(0, single)
    return files


def main():
    if len(sys.argv) > 1:
        src_dir = Path(sys.argv[1]).expanduser().resolve()
    else:
        src_dir = Path(__file__).resolve().parent

    if not src_dir.is_dir():
        print(f"Nie ma takiego folderu: {src_dir}")
        return 1

    src_files = find_sources(src_dir)
    if not src_files:
        print(f"W folderze {src_dir} nie ma pliku conversations.json ani conversations-*.json.")
        print("Podaj folder z rozpakowanym eksportem ChatGPT albo Claude.")
        return 1

    if len(sys.argv) > 2:
        out_dir = Path(sys.argv[2]).expanduser().resolve()
    else:
        out_dir = src_dir / "md"
    out_dir.mkdir(parents=True, exist_ok=True)

    used_counts = {}
    total = written = skipped = collisions = 0
    formats = set()

    for src_file in src_files:
        with open(src_file, "r", encoding="utf-8") as f:
            conversations = json.load(f)

        if not isinstance(conversations, list):
            print(f"Pomijam {src_file.name}: to nie jest lista rozmow.")
            continue

        for conversation in conversations:
            total += 1
            fmt = detect_format(conversation)
            if fmt == "chatgpt":
                result = chatgpt_conversation(conversation, total)
            elif fmt == "claude":
                result = claude_conversation(conversation, total)
            else:
                result = None

            if result is None:
                skipped += 1
                print(f"  pomijam (brak tresci): {src_file.name}, rozmowa nr {total}")
                continue

            formats.add(fmt)
            title, content = result
            out_path, was_collision = unique_path(out_dir, slugify(title), used_counts)
            if was_collision:
                collisions += 1
            out_path.write_text(content, encoding="utf-8", newline="\n")
            written += 1

    print(f"Format eksportu:           {', '.join(sorted(formats)) or 'nierozpoznany'}")
    print(f"Rozmow w eksporcie:        {total}")
    print(f"Zapisanych plikow:         {written}")
    print(f"Pominietych (bez tresci):  {skipped}")
    print(f"Powtorzonych tytulow:      {collisions}")
    if "claude" in formats:
        print(f"Pamiec (_pamiec.md):       {'tak' if claude_memory(src_dir, out_dir) else 'brak w eksporcie'}")
        print(f"Projekty (_projekty):      {claude_projects(src_dir, out_dir)}")
    print(f"Folder z wynikiem:         {out_dir}")
    if total and not written:
        print("Zaden plik nie powstal. Sprawdz, czy to eksport z ChatGPT albo Claude.")
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())