# CLI로 한 줄 설치
/plugin marketplace add Imbad0202/academic-research-skills
/plugin install academic-research-skills

git clone https://github.com/Imbad0202/academic-research-skills.git
# .claude/skills/ 또는 JetBrains 스킬 디렉토리에 심링크

git clone https://github.com/Imbad0202/academic-research-skills.git
ln -s ~/academic-research-skills ~/.claude/skills/

# citation_verifier.py
import json
from pathlib import Path
from typing import Optional

class CitationVerifier:
    """
    논문 인용의 정확성을 검증하는 클래스.
    DOI, arXiv ID, Crossref API를 활용하여 인용 정보를 검증.
    """
    
    def __init__(self, crossref_api_url="https://api.crossref.org/works"):
        self.crossref_url = crossref_api_url
        self.arxiv_url = "http://export.arxiv.org/api/query"
    
    def verify_by_doi(self, doi: str) -> Optional[dict]:
        """DOI로 인용 정보 검증"""
        import requests
        
        url = f"{self.crossref_url}/{doi}"
        response = requests.get(url, headers={"Accept": "application/json"})
        
        if response.status_code == 200:
            data = response.json()["message"]
            return {
                "verified": True,
                "title": data.get("title", ["Unknown"])[0],
                "authors": [a.get("family", "") for a in data.get("author", [])],
                "year": data.get("published-print", {}).get("date-parts", [[0]])[0][0],
                "venue": data.get("container-title", ["Unknown"])[0],
                "doi": doi
            }
        return {"verified": False, "error": f"DOI verification failed: {doi}"}
    
    def verify_by_arxiv(self, arxiv_id: str) -> Optional[dict]:
        """arXiv ID로 인용 정보 검증"""
        import requests
        from xml.etree import ElementTree as ET
        
        query = f"id:{arxiv_id}"
        url = f"{self.arxiv_url}?search_query={query}&max_results=1"
        response = requests.get(url)
        
        if response.status_code == 200:
            root = ET.fromstring(response.content)
            namespace = {"atom": "http://www.w3.org/2005/Atom"}
            
            entry = root.find("atom:entry", namespace)
            if entry is not None:
                return {
                    "verified": True,
                    "title": entry.find("atom:title", namespace).text.strip(),
                    "authors": [
                        a.find("atom:name", namespace).text
                        for a in entry.findall("atom:author", namespace)
                    ],
                    "year": entry.find("atom:published", namespace).text[:4],
                    "arxiv_id": arxiv_id,
                    "abstract": entry.find("atom:summary", namespace).text[:200]
                }
        return {"verified": False, "error": f"arXiv verification failed: {arxiv_id}"}
    
    def triangulate(self, citations: list[dict]) -> dict:
        """Triangulation 정책: 여러 출처로 인용 검증"""
        results = []
        for cit in citations:
            if "doi" in cit:
                result = self.verify_by_doi(cit["doi"])
            elif "arxiv_id" in cit:
                result = self.verify_by_arxiv(cit["arxiv_id"])
            else:
                result = {"verified": False, "error": "No DOI or arXiv ID"}
            
            results.append({**cit, **result})
        
        # 검증률 계산
        verified_count = sum(1 for r in results if r.get("verified"))
        total = len(results)
        
        return {
            "citations": results,
            "verification_rate": verified_count / total if total > 0 else 0,
            "failed_citations": [r for r in results if not r.get("verified")]
        }

# partitioned_writer.py
class PartitionedPaperWriter:
    """
    긴 논문을 파티션 단위로 생성하여 일관성 유지.
    각 파티션은 독립적으로 생성된 후, 인터페이스로 연결.
    """
    
    def __init__(self, llm_client):
        self.llm = llm_client
        self.partitions = []
        self.context_summary = ""
    
    def generate_partition(self, partition_type: str, content: str, 
                           previous_summary: str = "") -> str:
        """단일 파티션 생성"""
        prompt = f"""
        [PARTITION TYPE]: {partition_type}
        [PREVIOUS CONTEXT]: {previous_summary}
        [INSTRUCTIONS]: Generate a {partition_type} section.
        Maintain consistency with the previous context.
        Ensure all claims are properly cited.
        
        [CONTENT]: {content}
        """
        response = self.llm.generate(prompt, max_tokens=4000)
        
        # 파티션 메타데이터 저장
        self.partitions.append({
            "type": partition_type,
            "content": response,
            "token_count": len(response.split()),
            "has_citations": self.count_citations(response)
        })
        
        return response
    
    def generate_full_paper(self, topic: str, sections: list[str]) -> dict:
        """전체 논문 생성 (섹션별 파티션)"""
        paper = {}
        summary = ""
        
        for section in sections:
            print(f"📝 Generating: {section}")
            partition_content = self.generate_partition(
                partition_type=section,
                content=topic,
                previous_summary=summary
            )
            paper[section] = partition_content
            
            # 다음 파티션을 위한 요약 생성
            summary += f"[{section}]: {partition_content[:500]}... "
        
        return paper
    
    def count_citations(self, text: str) -> int:
        """텍스트 내 인용 수 계산"""
        import re
        return len(re.findall(r'\[.*?\]', text))
    
    def get_statistics(self) -> dict:
        """파티션 통계"""
        return {
            "total_partitions": len(self.partitions),
            "total_tokens": sum(p["token_count"] for p in self.partitions),
            "partitions_with_citations": sum(
                1 for p in self.partitions if p["has_citations"] > 0
            )
        }

# token_optimizer.py
class TokenCostOptimizer:
    """ARS의 토큰 사용량을 최적화하는 클래스"""
    
    # Claude Sonnet 가격 (2026년 기준)
    INPUT_PRICE_PER_1M = 3.00   # $3.00 / 1M tokens
    OUTPUT_PRICE_PER_1M = 15.00 # $15.00 / 1M tokens
    
    def __init__(self, max_budget=10.00):
        self.max_budget = max_budget
        self.total_input_tokens = 0
        self.total_output_tokens = 0
    
    def estimate_cost(self, input_tokens: int, output_tokens: int) -> float:
        """예상 비용 계산"""
        input_cost = (input_tokens / 1_000_000) * self.INPUT_PRICE_PER_1M
        output_cost = (output_tokens / 1_000_000) * self.INPUT_PRICE_PER_1M
        return input_cost + output_cost
    
    def chunk_text_for_efficiency(self, text: str, max_tokens_per_chunk=3000) -> list[str]:
        """텍스트를 효율적인 크기로 분할"""
        words = text.split()
        chunks = []
        current_chunk = []
        current_tokens = 0
        
        for word in words:
            current_chunk.append(word)
            current_tokens += 1
            
            if current_tokens >= max_tokens_per_chunk:
                chunks.append(" ".join(current_chunk))
                current_chunk = []
                current_tokens = 0
        
        if current_chunk:
            chunks.append(" ".join(current_chunk))
        
        return chunks
    
    def calculate_roi(self, manual_hours: float, tool_time_hours: float, 
                      hourly_rate=50.0) -> dict:
        """ROI 계산"""
        manual_cost = manual_hours * hourly_rate
        tool_cost = self.estimate_cost(0, 0)  # 실제 토큰 비용 필요
        
        hours_saved = manual_hours - tool_time_hours
        savings = hours_saved * hourly_rate
        
        return {
            "manual_cost": manual_cost,
            "tool_cost": tool_cost,
            "net_savings": savings - tool_cost,
            "time_saved_hours": hours_saved,
            "roi_percentage": ((savings - tool_cost) / tool_cost * 100) if tool_cost > 0 else float('inf')
        }

# experiment_agent.py
import random
from dataclasses import dataclass, field
from typing import List, Dict

@dataclass
class ExperimentResult:
    """실험 결과 데이터 클래스"""
    name: str
    hypothesis: str
    dataset: str
    model: str
    metrics: Dict[str, float] = field(default_factory=dict)
    notes: str = ""

class ExperimentAgent:
    """
    실험 설계를 지원하고 결과를 추적하는 에이전트.
    ARS와 연동하여 연구 결과와 실험 데이터를 연결.
    """
    
    def __init__(self):
        self.experiments: List[ExperimentResult] = []
        self.results_db: Dict[str, List[ExperimentResult]] = {}
    
    def design_experiment(self, hypothesis: str, dataset_name: str, 
                          baseline_model: str) -> ExperimentResult:
        """새로운 실험 설계"""
        experiment = ExperimentResult(
            name=f"exp_{len(self.experiments)+1}",
            hypothesis=hypothesis,
            dataset=dataset_name,
            model=baseline_model
        )
        self.experiments.append(experiment)
        
        return experiment
    
    def add_result(self, experiment_name: str, metrics: Dict[str, float], 
                   notes: str = ""):
        """실험 결과 추가"""
        for exp in self.experiments:
            if exp.name == experiment_name:
                exp.metrics = metrics
                exp.notes = notes
                if exp.dataset not in self.results_db:
                    self.results_db[exp.dataset] = []
                self.results_db[exp.dataset].append(exp)
                return
        
        raise ValueError(f"Experiment {experiment_name} not found")
    
    def compare_experiments(self, dataset: str) -> dict:
        """같은 데이터셋에 대한 실험 비교"""
        if dataset not in self.results_db:
            return {"error": "No experiments for this dataset"}
        
        experiments = self.results_db[dataset]
        comparison = {}
        
        for exp in experiments:
            comparison[exp.name] = {
                "hypothesis": exp.hypothesis,
                "model": exp.model,
                "metrics": exp.metrics,
                "notes": exp.notes
            }
        
        # 가장 좋은 모델 찾기
        best_model = None
        best_score = 0
        
        for exp in experiments:
            for metric, score in exp.metrics.items():
                if metric.startswith("accuracy") or metric.startswith("f1"):
                    if score > best_score:
                        best_score = score
                        best_model = exp.name
        
        return {
            "experiments": comparison,
            "best_model": best_model,
            "best_score": best_score,
            "total_experiments": len(experiments)
        }
    
    def generate_experiment_report(self) -> str:
        """실험 보고서 생성 (논문 초안에 포함)"""
        report = "# Experiment Results\n\n"
        
        for dataset, experiments in self.results_db.items():
            report += f"## Dataset: {dataset}\n\n"
            report += "| Experiment | Model | Metrics | Notes |\n"
            report += "|-----------|-------|---------|-------|\n"
            
            for exp in experiments:
                metrics_str = ", ".join(
                    f"{k}: {v:.4f}" for k, v in exp.metrics.items()
                )
                report += f"| {exp.name} | {exp.model} | {metrics_str} | {exp.notes} |\n"
            
            report += "\n"
        
        return report

# templates/nature_style.yaml
journal: "Nature"
format:
  font: "Times New Roman"
  font_size: 12
  line_spacing: 2.0
  margins: "1 inch all sides"
structure:
  max_word_count: 3000
  sections:
    - title: "Abstract"
      max_length: 250
      required: true
    - title: "Introduction"
      required: true
    - title: "Results"
      required: true
    - title: "Discussion"
      required: true
    - title: "Methods"
      required: true
  references:
    style: "Harvard"
    max_count: 50
citation_format: "Author (Year)"
figures:
  resolution: 300
  format: "TIFF"
  caption_position: "below"

# templates/icml_style.yaml
journal: "ICML"
format:
  font: "Times New Roman"
  font_size: 10
  line_spacing: double
  margins: "1 inch all sides"
structure:
  max_word_count: 6000
  pages_limit: 9
  sections:
    - title: "Abstract"
      max_length: 200
      required: true
    - title: "Introduction"
      required: true
    - title: "Related Work"
      required: true
    - title: "Method"
      required: true
    - title: "Experiments"
      required: true
    - title: "Conclusion"
      required: true
  references:
    style: "ACL"
    max_count: 100
citation_format: "[N]"
figures:
  resolution: 300
  format: "PDF"
  caption_position: "below"

# version_tracker.py
from datetime import datetime
import json
from pathlib import Path

class ResearchVersionTracker:
    """연구 버전 관리 시스템"""
    
    def __init__(self, project_dir="./research_project"):
        self.project_dir = Path(project_dir)
        self.versions_dir = self.project_dir / "versions"
        self.versions_dir.mkdir(parents=True, exist_ok=True)
    
    def create_version(self, paper_content: str, version_name: str = None,
                       changes: str = "") -> str:
        """새 버전 생성"""
        if version_name is None:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            version_name = f"v{timestamp}"
        
        version_data = {
            "version": version_name,
            "timestamp": datetime.now().isoformat(),
            "word_count": len(paper_content.split()),
            "section_count": paper_content.count("## "),
            "citation_count": paper_content.count("["),
            "changes": changes
        }
        
        # 버전 파일 저장
        version_file = self.versions_dir / f"{version_name}.json"
        version_file.write_text(json.dumps(version_data, indent=2, ensure_ascii=False))
        
        # 논문 내용 저장
        paper_file = self.versions_dir / f"{version_name}_paper.md"
        paper_file.write_text(paper_content)
        
        # 인덱스 업데이트
        self._update_index(version_name, version_data)
        
        return version_name
    
    def list_versions(self) -> list[dict]:
        """저장된 버전 목록"""
        versions = []
        for json_file in self.versions_dir.glob("*.json"):
            if json_file.name.endswith("_paper.json"):
                continue
            versions.append(json.loads(json_file.read_text()))
        
        return sorted(versions, key=lambda v: v["timestamp"], reverse=True)
    
    def get_version(self, version_name: str) -> dict:
        """특정 버전 조회"""
        json_file = self.versions_dir / f"{version_name}.json"
        if json_file.exists():
            return json.loads(json_file.read_text())
        return {}
    
    def _update_index(self, version_name: str, data: dict):
        """버전 인덱스 업데이트"""
        index_file = self.versions_dir / "index.json"
        index = json.loads(index_file.read_text()) if index_file.exists() else []
        index.append(data)
        index_file.write_text(json.dumps(index, indent=2, ensure_ascii=False))

# .github/workflows/research-pipeline.yml
name: Academic Research Pipeline

on:
  schedule:
    - cron: '0 6 * * 1'  # 매주 월요일 오전 6시
  workflow_dispatch:
    inputs:
      topic:
        description: '연구 주제'
        required: true
        default: 'multi-agent reinforcement learning'

jobs:
  research:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install ARS
        run: pip install academic-research-skills
      
      - name: Deep Research
        run: |
          /deep-research "${{ github.event.inputs.topic || 'multi-agent reinforcement learning' }}"
      
      - name: Draft Paper
        run: |
          /academic-paper "${{ github.event.inputs.topic || 'multi-agent reinforcement learning' }}"
      
      - name: Auto Review
        run: |
          /academic-review ./output/draft.md
      
      - name: Generate Citation Report
        run: python scripts/verify_citations.py
      
      - name: Upload Results
        uses: actions/upload-artifact@v4
        with:
          name: research-output
          path: |
            output/draft.md
            output/review.md
            output/citations.json