shadow_brain_core/scripts/build_graph.py

# -*- coding: utf-8 -*-
"""🔱 Graphify 지식 그래프 생성 및 시각화 빌더

제국 프로젝트(shadow_brain_core)의 코드 구조(AST)와 마크다운 문서를 분석하여
구조적 의존망을 담은 graph.json 및 웹 시각화 graph.html을 빌드합니다.
빌드된 파일은 로컬 및 R2 Live 스토리지에 업로드되어 AI와 마왕님께 지도로 제공됩니다.

실행 방법:
    python scripts/build_graph.py [--upload]
    python scripts/build_graph.py --upload --full-upload   # 라이트 + 풀 그래프 모두
"""

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

# UTF-8 인코딩 강제
sys.stdout.reconfigure(encoding='utf-8')

class ProjectGraphBuilder:
    def __init__(self, root_dir: Path):
        self.root_dir = root_dir.resolve()
        self.nodes = {}
        self.edges = []
        self.scanned_files = set()

    def add_node(self, node_id: str, label: str, node_type: str, details: dict = None):
        if node_id not in self.nodes:
            self.nodes[node_id] = {
                "id": node_id,
                "label": label,
                "type": node_type,
                "details": details or {}
            }

    def add_edge(self, source: str, target: str, rel_type: str):
        # 중복 엣지 방지
        edge = {"source": source, "target": target, "type": rel_type}
        if edge not in self.edges:
            self.edges.append(edge)

    def scan_python_files(self):
        """Python 파일의 AST 파싱을 통해 클래스, 함수, import 관계 분석"""
        for root, _, files in os.walk(self.root_dir):
            # 제외 폴더 필터링
            if any(p in root for p in [".git", "venv", "__pycache__", "node_modules", "dist", "build"]):
                continue

            for file in files:
                if not file.endswith(".py"):
                    continue

                file_path = Path(root) / file
                rel_path = file_path.relative_to(self.root_dir).as_posix()
                self.scanned_files.add(rel_path)

                # 파일 노드 추가
                self.add_node(rel_path, file, "file", {"size": file_path.stat().st_size})

                try:
                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                        code = f.read()

                    # AST 분석
                    tree = ast.parse(code, filename=str(file_path))
                    self._analyze_ast(tree, rel_path)

                except Exception as e:
                    print(f"⚠️ AST 파싱 실패 [{rel_path}]: {e}")

    def _analyze_ast(self, tree: ast.AST, file_rel_path: str):
        """AST 노드를 순회하며 클래스, 함수, import 관계 정의"""
        for node in ast.walk(tree):
            # 1. Imports 분석
            if isinstance(node, ast.Import):
                for alias in node.names:
                    # 프로젝트 내부 모듈로 추정되는 import만 연결
                    target_module = alias.name.split('.')[0]
                    self._try_add_import_edge(file_rel_path, target_module)

            elif isinstance(node, ast.ImportFrom):
                if node.module:
                    target_module = node.module.split('.')[0]
                    self._try_add_import_edge(file_rel_path, target_module)

            # 2. 클래스 정의 분석
            elif isinstance(node, ast.ClassDef):
                class_id = f"{file_rel_path}::{node.name}"
                self.add_node(class_id, node.name, "class", {
                    "file": file_rel_path,
                    "methods": [n.name for n in node.body if isinstance(n, ast.FunctionDef)]
                })
                # 파일 -> 클래스 부모-자식 연결
                self.add_edge(file_rel_path, class_id, "defines")

            # 3. 최상위 함수 정의 분석
            elif isinstance(node, ast.FunctionDef):
                # 클래스 메서드가 아닌 독립 함수만 추가 (클래스 메서드는 클래스 노드 상세 정보에 포함)
                # 부모가 ClassDef인지 간단히 판단하기 위해 walk가 아닌 단단계 매핑이 좋으나, 간소화를 위해 수집
                pass

    def _try_add_import_edge(self, source_file: str, target_module: str):
        """임포트 대상 모듈이 프로젝트 내부에 실존하는 파일인지 판별 후 간선 연결"""
        # 1. module_name.py 형태 검사
        potential_py = f"{target_module}.py"
        potential_dir_py = f"{target_module}/__init__.py"

        for scanned in self.scanned_files:
            if scanned == potential_py or scanned.endswith("/" + potential_py) or scanned == potential_dir_py:
                self.add_edge(source_file, scanned, "imports")
                return

    def scan_markdown_docs(self):
        """프로젝트 루트 내 Markdown 문서와 그 안의 연결고리(wiki 링크, 파일 참조) 분석"""
        for root, _, files in os.walk(self.root_dir):
            if any(p in root for p in [".git", "venv", "node_modules", ".agent"]):
                continue

            for file in files:
                if not file.endswith(".md"):
                    continue

                file_path = Path(root) / file
                rel_path = file_path.relative_to(self.root_dir).as_posix()

                # 문서 노드 추가
                self.add_node(rel_path, file, "document", {"size": file_path.stat().st_size})

                try:
                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                        content = f.read()

                    # 문서 내부의 타 파일 참조([[링크]] 또는 마크다운 파일 링크) 탐색
                    # 간단한 파일명 매칭
                    for other_file in self.scanned_files:
                        other_name = Path(other_file).name
                        if other_name in content:
                            self.add_edge(rel_path, other_file, "references")

                except Exception as e:
                    print(f"⚠️ 문서 스캔 실패 [{rel_path}]: {e}")

    def build(self) -> dict:
        self.scan_python_files()
        self.scan_markdown_docs()
        return {
            "nodes": list(self.nodes.values()),
            "links": self.edges
        }

def generate_interactive_html(graph_data: dict) -> str:
    """D3.js 기반의 멋진 Force-Directed Graph UI 템플릿 생성"""
    data_json = json.dumps(graph_data, ensure_ascii=False, indent=2)

    html_template = f"""<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>🔱 Imperial Guild Knowledge Graph Portal</title>
    <script src="https://d3js.org/d3.v7.min.js"></script>
    <style>
        body {{
            margin: 0;
            font-family: 'Outfit', 'Inter', sans-serif;
            background-color: #0f1016;
            color: #e2e8f0;
            overflow: hidden;
        }}
        #header {{
            position: absolute;
            top: 20px;
            left: 20px;
            z-index: 10;
            pointer-events: none;
        }}
        h1 {{
            margin: 0;
            font-size: 24px;
            font-weight: 700;
            background: linear-gradient(135deg, #38bdf8, #818cf8);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            letter-spacing: -0.05em;
        }}
        p {{
            margin: 5px 0 0 0;
            font-size: 12px;
            color: #64748b;
        }}
        #canvas {{
            width: 100vw;
            height: 100vh;
        }}
        .node {{
            stroke-width: 1.5px;
            cursor: pointer;
            transition: r 0.2s ease, stroke-width 0.2s ease;
        }}
        .link {{
            stroke: #334155;
            stroke-opacity: 0.6;
            stroke-width: 1.2px;
        }}
        .label {{
            font-size: 10px;
            fill: #94a3b8;
            pointer-events: none;
            text-shadow: 0 1px 3px rgba(0,0,0,0.8);
        }}
        #details {{
            position: absolute;
            top: 20px;
            right: 20px;
            width: 320px;
            background: rgba(15, 23, 42, 0.85);
            backdrop-filter: blur(12px);
            border: 1px solid rgba(255,255,255,0.1);
            border-radius: 12px;
            padding: 20px;
            box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.5);
            z-index: 10;
            display: none;
            max-height: 80vh;
            overflow-y: auto;
        }}
        #details h3 {{
            margin-top: 0;
            color: #38bdf8;
            border-bottom: 1px solid rgba(255,255,255,0.1);
            padding-bottom: 10px;
        }}
        .meta-item {{
            margin-bottom: 10px;
            font-size: 13px;
        }}
        .meta-label {{
            color: #64748b;
            font-weight: bold;
        }}
        .meta-value {{
            color: #cbd5e1;
            word-break: break-all;
        }}
        .legend {{
            position: absolute;
            bottom: 20px;
            left: 20px;
            background: rgba(15, 23, 42, 0.7);
            padding: 10px 15px;
            border-radius: 8px;
            border: 1px solid rgba(255,255,255,0.05);
            font-size: 11px;
            z-index: 10;
        }}
        .legend-item {{
            display: flex;
            align-items: center;
            margin-bottom: 5px;
        }}
        .legend-color {{
            width: 10px;
            height: 10px;
            border-radius: 50%;
            margin-right: 8px;
        }}
    </style>
</head>
<body>
    <div id="header">
        <h1>🔱 제국 지식 그래프 포탈</h1>
        <p>Imperial Knowledge & Codebase Mapping (Graphify Engine)</p>
    </div>

    <div id="details">
        <h3 id="detail-title">Node Details</h3>
        <div id="detail-content"></div>
    </div>

    <div class="legend">
        <div class="legend-item"><div class="legend-color" style="background: #38bdf8;"></div> 소스 코드 (File)</div>
        <div class="legend-item"><div class="legend-color" style="background: #fb7185;"></div> 마크다운 문서 (Document)</div>
        <div class="legend-item"><div class="legend-color" style="background: #c084fc;"></div> 구조적 클래스 (Class)</div>
    </div>

    <svg id="canvas"></svg>

    <script>
        const graph = {data_json};

        const width = window.innerWidth;
        const height = window.innerHeight;

        const svg = d3.select("#canvas")
            .attr("viewBox", [0, 0, width, height]);

        const g = svg.append("g");

        // 줌/팬 설정
        svg.call(d3.zoom()
            .scaleExtent([0.1, 8])
            .on("zoom", (event) => {{
                g.attr("transform", event.transform);
            }}));

        // 색상 맵
        const colorMap = {{
            "file": "#38bdf8",
            "document": "#fb7185",
            "class": "#c084fc"
        }};

        // 시뮬레이션 설정
        const simulation = d3.forceSimulation(graph.nodes)
            .force("link", d3.forceLink(graph.links).id(d => d.id).distance(80))
            .force("charge", d3.forceManyBody().strength(-120))
            .force("center", d3.forceCenter(width / 2, height / 2))
            .force("collision", d3.forceCollide().radius(25));

        // 간선(Edges) 드로잉
        const link = g.append("g")
            .selectAll("line")
            .data(graph.links)
            .join("line")
            .attr("class", "link");

        // 노드(Nodes) 드로잉
        const node = g.append("g")
            .selectAll("circle")
            .data(graph.nodes)
            .join("circle")
            .attr("class", "node")
            .attr("r", d => d.type === "file" ? 8 : (d.type === "document" ? 7 : 5))
            .attr("fill", d => colorMap[d.type] || "#94a3b8")
            .attr("stroke", "#0f1016")
            .attr("stroke-width", 1.5)
            .call(drag(simulation));

        // 라벨 추가
        const label = g.append("g")
            .selectAll("text")
            .data(graph.nodes)
            .join("text")
            .attr("class", "label")
            .attr("dx", 12)
            .attr("dy", ".35em")
            .text(d => d.label);

        // 이벤트 리스너
        node.on("click", (event, d) => {{
            showDetails(d);
            event.stopPropagation();
        }});

        svg.on("click", () => {{
            d3.select("#details").style("display", "none");
        }});

        simulation.on("tick", () => {{
            link
                .attr("x1", d => d.source.x)
                .attr("y1", d => d.source.y)
                .attr("x2", d => d.target.x)
                .attr("y2", d => d.target.y);

            node
                .attr("cx", d => d.x)
                .attr("cy", d => d.y);

            label
                .attr("x", d => d.x)
                .attr("y", d => d.y);
        }});

        function showDetails(d) {{
            const details = d3.select("#details");
            d3.select("#detail-title").text(d.label);

            let html = `
                <div class="meta-item">
                    <div class="meta-label">ID / 상대 경로</div>
                    <div class="meta-value">${{d.id}}</div>
                </div>
                <div class="meta-item">
                    <div class="meta-label">유형</div>
                    <div class="meta-value">${{d.type.toUpperCase()}}</div>
                </div>
            `;

            if (d.type === "class" && d.details.methods) {{
                html += `
                    <div class="meta-item">
                        <div class="meta-label">부모 소스 파일</div>
                        <div class="meta-value">${{d.details.file}}</div>
                    </div>
                    <div class="meta-item">
                        <div class="meta-label">포함된 메서드 목록</div>
                        <div class="meta-value">${{d.details.methods.join(', ') || '없음'}}</div>
                    </div>
                `;
            }} else if (d.details.size) {{
                html += `
                    <div class="meta-item">
                        <div class="meta-label">파일 크기</div>
                        <div class="meta-value">${{d.details.size.toLocaleString()}} bytes</div>
                    </div>
                `;
            }}

            d3.select("#detail-content").html(html);
            details.style("display", "block");
        }}

        function drag(simulation) {{
            return d3.drag()
                .on("start", (event) => {{
                    if (!event.active) simulation.alphaTarget(0.3).restart();
                    event.subject.fx = event.subject.x;
                    event.subject.fy = event.subject.y;
                }})
                .on("drag", (event) => {{
                    event.subject.fx = event.subject.x;
                    event.subject.fy = event.subject.y;
                }})
                .on("end", (event) => {{
                    if (!event.active) simulation.alphaTarget(0);
                    event.subject.fx = null;
                    event.subject.fy = null;
                }});
        }}
    </script>
</body>
</html>
"""
    return html_template

def upload_to_r2_live(json_path: Path, html_path: Path):
    """R2 Live 버킷에 지식 그래프 지도 업로드"""
    try:
        # shadow_brain_core/web_server.py의 R2 Live 로드 패턴 참조
        core_dir = Path(__file__).parent.parent
        project_root = core_dir.parent
        sys.path.append(str(core_dir))
        sys.path.append(str(project_root / "scripts" / "tools"))

        from cloud_tool import R2_ACCOUNTS, _get_bw_credential
        import boto3
        from botocore.config import Config

        print("🔮 R2 Live 자격증명 확보 시작...")
        # live 설정 추출
        live_cfg = R2_ACCOUNTS.get("live")
        if not live_cfg:
            print("❌ R2 Live 계정이 cloud_tool.py에 정의되어 있지 않습니다.")
            return

        account_id = _get_bw_credential(live_cfg["account_id"])
        access_key = _get_bw_credential(live_cfg["access_key_id"])
        secret_key = _get_bw_credential(live_cfg["secret_access_key"])
        # 🔱 [Fix] R2_ACCOUNTS["live"] 의 버킷 키는 "bucket"(="cache") 이다.
        #   잘못된 키 "bucket_name"(기본 "taemingames")을 쓰면 공개 도메인
        #   r2.taemingames.com(=cache 버킷)과 다른 버킷에 올라가 404 가 난다.
        bucket_name = live_cfg.get("bucket", "cache")

        if not all([account_id, access_key, secret_key]):
            print("❌ R2 Live 자격증명이 비어 있어 업로드를 건너뜁니다.")
            return

        print("⚡ R2 Live S3 클라이언트 초기화 중...")
        s3 = boto3.client(
            "s3",
            endpoint_url=f"https://{account_id}.r2.cloudflarestorage.com",
            aws_access_key_id=access_key,
            aws_secret_access_key=secret_key,
            config=Config(signature_version="s3v4")
        )

        prefix = "cloud-obsidian/graph"

        # json 업로드
        print(f"🚀 {json_path.name} 업로드 중 -> R2 Live/{prefix}/{json_path.name}")
        s3.upload_file(
            Filename=str(json_path),
            Bucket=bucket_name,
            Key=f"{prefix}/{json_path.name}",
            ExtraArgs={"ContentType": "application/json"}
        )

        # html 업로드
        print(f"🚀 {html_path.name} 업로드 중 -> R2 Live/{prefix}/{html_path.name}")
        s3.upload_file(
            Filename=str(html_path),
            Bucket=bucket_name,
            Key=f"{prefix}/{html_path.name}",
            ExtraArgs={"ContentType": "text/html"}
        )
        print("✅ R2 Live 지식 그래프 업로드 완료!")

    except ImportError:
        print("⚠️ cloud_tool 또는 boto3 모듈을 찾을 수 없어 R2 업로드를 생략합니다.")
    except Exception as e:
        print(f"⚠️ R2 Live 업로드 실패: {e}")

def _capture_full_graph(project_root: Path) -> dict:
    """🔱 풀 그래프 (9749 UI 호환) 캡처 → portal-heimdall/assets/knowledge_graph_9749/

    9749 바이너리(`codebase-memory-mcp-ui-bin`)의 백엔드 API를 호출해:
      - /api/layout         → 13.5 MB 풀 노드/엣지 좌표 (137k 노드)
      - /api/project-health → 노드/엣지/크기 메타
      - /api/adr            → ADR (Architecture Decision Records)
      - /api/project        → 프로젝트 메타
      - list_projects (RPC) → 프로젝트 목록
      - get_graph_schema    → 노드/엣지 스키마 (색상, 라벨, 속성)

    Returns dict: {"success": bool, "message": str, "captures": {file: bytes}}
    """
    import json as _json
    import urllib.request
    import urllib.error
    import urllib.parse as _u
    import subprocess as _sp

    def _hermes_python():
        """boto3이 보장된 hermes venv의 python3 경로. 없으면 현재 인터프리터."""
        from pathlib import Path as _P
        candidate = _P.home() / ".hermes" / "hermes-agent" / "venv" / "bin" / "python3"
        return str(candidate) if candidate.exists() else sys.executable

    result = {"success": False, "message": "", "captures": {}}

    # 1) 9749 백엔드 살아있는지 확인
    try:
        urllib.request.urlopen("http://localhost:9749/api/processes", timeout=2).read()
    except Exception as e:
        result["message"] = f"9749 백엔드 미가동 (localhost:9749): {e}"
        return result

    # 2) 프로젝트 이름 조회 (list_projects MCP RPC)
    def _list_projects():
        proc = _sp.run(
            ["codebase-memory-mcp", "cli", "list_projects"],
            capture_output=True, text=True, timeout=30,
        )
        out = proc.stdout.strip()          # stderr log(level=info…)가 앞에 붙을 수 있음
        start = out.find("{")
        if start == -1:
            raise ValueError(f"list_projects JSON 파싱 실패: {out[:200]}")
        return _json.loads(out[start:])["projects"]

    try:
        projects = _list_projects()
    except FileNotFoundError:
        result["message"] = "codebase-memory-mcp 바이너리를 PATH에서 찾을 수 없음"
        return result
    except Exception as e:
        result["message"] = f"list_projects 실패: {e}"
        return result

    # 🔱 [자가 치유] 인덱스가 비어 있으면(9749 재시작 등) 캡처 전에 자동 인덱싱한다.
    #    과거엔 여기서 '프로젝트 없음'으로 중단됐다 — 지도 갱신 버튼이 조용히 실패하던 근본 원인.
    if not projects:
        print("⚠️ 9749 인덱스가 비어 있음 → 자동 인덱싱 개시 (수 분 소요, persistence로 재시작 후에도 유지)...")
        try:
            idx = _sp.run(
                ["codebase-memory-mcp", "cli", "index_repository",
                 _json.dumps({"repo_path": str(project_root), "mode": "full", "persistence": True})],
                capture_output=True, text=True, timeout=1800,
            )
            tail = (idx.stdout or "").strip()[-200:]
            print(f"   인덱싱 결과: {tail}")
            projects = _list_projects()
        except Exception as e:
            result["message"] = f"자동 인덱싱 실패: {e} (수동: codebase-memory-mcp cli index_repository)"
            return result
        if not projects:
            result["message"] = "자동 인덱싱 후에도 프로젝트가 비어 있음 — 9749 백엔드/저장소 상태 확인 필요"
            return result

    # 우선순위: project_root와 일치하는 프로젝트
    target = None
    target_name = None
    target_root = None
    for p in projects:
        if Path(p["root_path"]).resolve() == project_root.resolve():
            target = p
            target_name = p["name"]
            target_root = p["root_path"]
            break
    if target is None:
        # 일치 없으면 첫 프로젝트
        target = projects[0]
        target_name = target["name"]
        target_root = target["root_path"]

    print(f"🔮 풀 그래프 캡처 대상: {target_name} ({target['nodes']:,} 노드 / {target['edges']:,} 엣지)")

    # 3) 캡처 디렉터리
    capture_dir = project_root / "portal-heimdall" / "assets" / "knowledge_graph_9749" / "data"
    capture_dir.mkdir(parents=True, exist_ok=True)

    captures = {}

    def _fetch_json(path: str, dest_name: str):
        """9749 API 한 줄 GET → 파일 저장."""
        try:
            with urllib.request.urlopen(f"http://localhost:9749{path}", timeout=60) as r:
                data = r.read()
            (capture_dir / dest_name).write_bytes(data)
            captures[dest_name] = len(data)
            print(f"  ✓ {dest_name:24} {len(data):>10,} bytes")
        except Exception as e:
            print(f"  ⚠ {dest_name} 캡처 실패: {e}")

    enc = _u.quote(target_name, safe="")
    enc_root = _u.quote(target_root, safe="")

    _fetch_json(f"/api/layout?project={enc}&max_nodes=50000", "layout.json")
    _fetch_json(f"/api/project-health?name={enc}", "health.json")
    _fetch_json(f"/api/adr?project={enc}", "adr.json")
    _fetch_json(f"/api/project?name={enc}", "project.json")
    # list_projects.json도 동기화 (UI 첫 호출용)
    (capture_dir / "list_projects.json").write_text(_json.dumps({"projects": projects}, ensure_ascii=False), encoding="utf-8")
    captures["list_projects.json"] = (capture_dir / "list_projects.json").stat().st_size
    print(f"  ✓ list_projects.json       {captures['list_projects.json']:>10,} bytes")

    # 4) get_graph_schema — CLI 호출
    try:
        proc = _sp.run(
            ["codebase-memory-mcp", "cli", "get_graph_schema", f'{{"project":"{target_name}"}}'],
            capture_output=True, text=True, timeout=30,
        )
        out = proc.stdout.strip()
        start = out.find("{")
        if start != -1:
            (capture_dir / "schema.json").write_text(out[start:], encoding="utf-8")
            captures["schema.json"] = (capture_dir / "schema.json").stat().st_size
            print(f"  ✓ schema.json             {captures['schema.json']:>10,} bytes")
    except Exception as e:
        print(f"  ⚠ schema 캡처 실패: {e}")

    if not captures.get("layout.json"):
        result["message"] = "layout.json 캡처 실패 (9749 인덱스 미완성 가능성)"
        return result

    # 5) R2 푸시 — hermes venv의 python으로 호출 (boto3 보장)
    project_root_for_sync = project_root
    scripts_dir = project_root_for_sync / "scripts"
    sync_script = scripts_dir / "r2_sync_full_graph.py"
    if sync_script.exists():
        print(f"🚀 R2 풀 그래프 푸시 시작: {sync_script} --force")
        proc = _sp.run(
            [_hermes_python(), str(sync_script), "--force"],
            cwd=str(project_root_for_sync),
            capture_output=True, text=True, timeout=300,
        )
        if proc.returncode == 0:
            print("✅ R2 풀 그래프 푸시 완료")
        else:
            print(f"⚠ R2 푸시 일부 실패 (returncode={proc.returncode}):")
            print(proc.stdout[-1000:])
            print(proc.stderr[-500:])
    else:
        print(f"⚠ R2 동기화 스크립트 없음: {sync_script}")

    result["success"] = True
    result["message"] = f"{len(captures)} 파일 캡처, R2 푸시 완료"
    result["captures"] = captures
    result["project_name"] = target_name
    result["project_root"] = target_root
    return result


def main():
    parser = argparse.ArgumentParser(description="🔱 Graphify 지식 그래프 엔진")
    parser.add_argument("--upload", action="store_true", help="라이트 그래프 R2 Live 버킷 업로드")
    parser.add_argument("--full-upload", action="store_true", help="풀 그래프 (9749 UI) 137k 노드 캡처 + R2 업로드")
    args = parser.parse_args()

    # 스크립트 실행 위치가 scripts/ 여도 부모 shadow_brain_core를 가리키도록 설정
    script_dir = Path(__file__).parent.resolve()
    core_dir = script_dir.parent

    print(f"🔱 Graphify: [{core_dir}] 소스 분석을 개시합니다...")
    builder = ProjectGraphBuilder(core_dir)
    graph_data = builder.build()

    # 로컬 저장 경로
    output_dir = core_dir / "static" / "graph"
    output_dir.mkdir(parents=True, exist_ok=True)

    json_path = output_dir / "graph.json"
    html_path = output_dir / "graph.html"

    # json 쓰기
    with open(json_path, "w", encoding="utf-8") as f:
        json.dump(graph_data, f, ensure_ascii=False, indent=2)

    # html 쓰기
    html_content = generate_interactive_html(graph_data)
    with open(html_path, "w", encoding="utf-8") as f:
        f.write(html_content)

    print(f"✅ 분석 완료! 총 노드: {len(graph_data['nodes'])}, 간선: {len(graph_data['links'])}")
    print(f"💾 로컬 데이터 저장: {json_path}")
    print(f"💾 로컬 시각화 저장: {html_path}")

    # 업로드 처리
    if args.upload:
        upload_to_r2_live(json_path, html_path)

    # 풀 그래프 캡처 + R2 푸시
    if args.full_upload:
        # graphify로 인덱싱할 프로젝트 루트 = shadow_brain_core의 부모 (jarvis_taemin)
        jarvis_root = core_dir.parent
        print()
        print("🔱 풀 그래프 (9749 UI 호환) 캡처 시작...")
        result = _capture_full_graph(jarvis_root)
        if result["success"]:
            print(f"✅ 풀 그래프 갱신 완료: {result['message']}")
        else:
            print(f"❌ 풀 그래프 갱신 실패: {result['message']}")

if __name__ == "__main__":
    main()