import os
import glob
from openai import OpenAI
import pinecone

# OpenAI APIクライアントの初期化
client = OpenAI(api_key="YOUR_OPENAI_API_KEY")

# Pineconeの初期化
pinecone.init(
    api_key="YOUR_PINECONE_API_KEY",
    environment="YOUR_PINECONE_ENVIRONMENT"
)

# インデックスに接続
index = pinecone.Index("devin-code-index")

# コードファイルのパス
code_directory = "/path/to/your/codebase"
allowed_extensions = ['.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.cpp', '.h']

# コードファイルを取得
code_files = []
for ext in allowed_extensions:
    code_files.extend(glob.glob(f"{code_directory}/**/*{ext}", recursive=True))

# ファイルごとにエンベディングを生成してPineconeに保存
for i, file_path in enumerate(code_files):
    try:
        # ファイルを読み込み
        with open(file_path, 'r', encoding='utf-8') as f:
            code_content = f.read()
        
        # ファイルが大きすぎる場合は分割（OpenAIのトークン制限に対応）
        if len(code_content) > 15000:
            # 簡易的な分割（より洗練された分割方法を使うことをお勧めします）
            chunks = [code_content[i:i+15000] for i in range(0, len(code_content), 15000)]
        else:
            chunks = [code_content]
        
        # 各チャンクに対してエンベディングを生成
        for chunk_idx, chunk in enumerate(chunks):
            # エンベディングの生成
            response = client.embeddings.create(
                input=chunk,
                model="text-embedding-3-small"
            )
            embedding = response.data[0].embedding
            
            # メタデータの作成
            metadata = {
                "file_path": file_path,
                "language": os.path.splitext(file_path)[1][1:],
                "chunk_idx": chunk_idx,
                "total_chunks": len(chunks)
            }
            
            # Pineconeに保存
            unique_id = f"{file_path}_{chunk_idx}".replace("/", "_").replace("\\", "_")
            index.upsert([(unique_id, embedding, metadata)])
        
        print(f"Processed {i+1}/{len(code_files)}: {file_path}")
    
    except Exception as e:
        print(f"Error processing {file_path}: {e}")

print("All code files have been embedded and stored in Pinecone.")

from openai import OpenAI
import pinecone

# 初期化
client = OpenAI(api_key="YOUR_OPENAI_API_KEY")
pinecone.init(
    api_key="YOUR_PINECONE_API_KEY",
    environment="YOUR_PINECONE_ENVIRONMENT"
)
index = pinecone.Index("devin-code-index")

def search_codebase(query, top_k=5):
    """
    クエリに関連するコードを検索する
    
    Args:
        query: 検索クエリ文字列
        top_k: 返す結果の数
        
    Returns:
        関連コードの配列
    """
    # クエリをエンベディングに変換
    response = client.embeddings.create(
        input=query,
        model="text-embedding-3-small"
    )
    query_embedding = response.data[0].embedding
    
    # Pineconeで類似検索を実行
    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True
    )
    
    # 結果を整形
    code_contexts = []
    for match in results['matches']:
        metadata = match['metadata']
        file_path = metadata['file_path']
        
        # ファイルを読み込み
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
                
            # 大きなファイルの場合は、該当チャンク部分だけを抽出
            if metadata.get('total_chunks', 1) > 1:
                chunk_idx = metadata.get('chunk_idx', 0)
                total_chunks = metadata.get('total_chunks', 1)
                chunk_size = len(content) // total_chunks
                start_pos = chunk_idx * chunk_size
                end_pos = start_pos + chunk_size
                content = content[start_pos:end_pos]
            
            code_contexts.append({
                "file_path": file_path,
                "language": metadata.get('language', ''),
                "content": content,
                "similarity": match['score']
            })
        except Exception as e:
            print(f"Error reading file {file_path}: {e}")
    
    return code_contexts

def format_context_for_devin(code_contexts):
    """
    検索結果をDevinに渡すフォーマットに変換する
    
    Args:
        code_contexts: search_codebase()からの結果
        
    Returns:
        Devinへの入力に適したフォーマットのコンテキスト
    """
    context = "以下は関連するコードの抜粋です：\n\n"
    
    for i, code in enumerate(code_contexts, 1):
        context += f"### ファイル {i}: {code['file_path']} (類似度: {code['similarity']:.2f})\n"
        context += f"```{code['language']}\n{code['content']}\n```\n\n"
    
    return context

# 使用例
query = "ユーザー認証の実装方法"
code_contexts = search_codebase(query)
formatted_context = format_context_for_devin(code_contexts)

# このコンテキストをDevinへのプロンプトに含める
devin_prompt = f"""
@Devin

【タスク】ユーザー認証機能の実装

【参考コード】
{formatted_context}

上記のコードを参考にして、同じスタイルと設計パターンに沿ったユーザー認証機能を実装してください。
"""

print(devin_prompt)

import mcp
from openai import OpenAI
import pinecone
import os

# 初期化
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
pinecone.init(
    api_key=os.environ.get("PINECONE_API_KEY"),
    environment=os.environ.get("PINECONE_ENVIRONMENT")
)
index = pinecone.Index("devin-code-index")

@mcp.tool()
def search_code(query: str, top_k: int = 5) -> str:
    """
    コードベースからクエリに関連するコードを検索します。
    
    Args:
        query: 検索クエリ文字列
        top_k: 返す結果の数
        
    Returns:
        関連コードの説明とコード片
    """
    # クエリをエンベディングに変換
    response = client.embeddings.create(
        input=query,
        model="text-embedding-3-small"
    )
    query_embedding = response.data[0].embedding
    
    # Pineconeで類似検索を実行
    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True
    )
    
    # 結果を整形
    output = f"## 「{query}」に関連するコード\n\n"
    
    for i, match in enumerate(results['matches'], 1):
        metadata = match['metadata']
        file_path = metadata['file_path']
        
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
                
            # 大きなファイルの場合は、該当チャンク部分だけを抽出
            if metadata.get('total_chunks', 1) > 1:
                chunk_idx = metadata.get('chunk_idx', 0)
                total_chunks = metadata.get('total_chunks', 1)
                chunk_size = len(content) // total_chunks
                start_pos = chunk_idx * chunk_size
                end_pos = start_pos + chunk_size
                content = content[start_pos:end_pos]
            
            output += f"### {i}. {os.path.basename(file_path)} (類似度: {match['score']:.2f})\n"
            output += f"パス: {file_path}\n"
            output += f"言語: {metadata.get('language', '不明')}\n"
            output += f"```{metadata.get('language', '')}\n{content[:1500]}... (省略)\n```\n\n"
        
        except Exception as e:
            output += f"### {i}. {os.path.basename(file_path)} (エラー)\n"
            output += f"ファイルの読み込み中にエラーが発生しました: {e}\n\n"
    
    return output

if __name__ == "__main__":
    mcp.run()

# code_search_mcp.py
import mcp
import os
import glob
import tempfile
import json

@mcp.tool()
def search_project_code(query: str, extensions: list = None, max_results: int = 5) -> str:
    """
    プロジェクト内のコードを検索します。
    
    Args:
        query: 検索したいキーワードやフレーズ
        extensions: 検索対象のファイル拡張子リスト (例: [".py", ".js"])
        max_results: 返す最大結果数
    
    Returns:
        検索結果のマークダウン形式のテキスト
    """
    if extensions is None:
        extensions = [".py", ".js", ".ts", ".jsx", ".tsx", ".html", ".css", ".java", ".c", ".cpp"]
    
    # 検索対象ディレクトリ
    project_dir = os.path.expanduser("~/projects")  # 適宜変更
    
    # 検索結果
    results = []
    
    # 全ファイルを走査
    for ext in extensions:
        for file_path in glob.glob(f"{project_dir}/**/*{ext}", recursive=True):
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()
                    
                    # クエリを含むファイルを検索
                    if query.lower() in content.lower():
                        # ファイルパスを短縮表示
                        relative_path = os.path.relpath(file_path, project_dir)
                        
                        # 関連する行の抽出
                        lines = content.split('\n')
                        matching_lines = []
                        
                        for i, line in enumerate(lines):
                            if query.lower() in line.lower():
                                start = max(0, i - 2)
                                end = min(len(lines), i + 3)
                                context = lines[start:end]
                                matching_lines.append({
                                    "line_number": i + 1,
                                    "context": "\n".join(context)
                                })
                        
                        results.append({
                            "file": relative_path,
                            "extension": ext,
                            "matching_lines": matching_lines[:3]  # 最初の3つのマッチのみ
                        })
                        
                        # 最大結果数に達したら終了
                        if len(results) >= max_results:
                            break
            except Exception as e:
                continue
        
        # 最大結果数に達したら終了
        if len(results) >= max_results:
            break
    
    # 結果をマークダウン形式で出力
    if not results:
        return f"クエリ「{query}」に一致するコードが見つかりませんでした。"
    
    output = f"# 検索結果: '{query}'\n\n"
    
    for i, result in enumerate(results, 1):
        output += f"## {i}. {result['file']}\n\n"
        
        for j, match in enumerate(result['matching_lines'], 1):
            output += f"### マッチ {j} (行 {match['line_number']})\n\n"
            output += f"```{result['extension'][1:]}\n{match['context']}\n```\n\n"
    
    return output

if __name__ == "__main__":
    mcp.run(transport="stdio")

name: Devin CI/CD Helper

on:
  pull_request:
    types: [opened, synchronize]
  workflow_dispatch:

jobs:
  devin-review:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
          
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'
          
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install openai pinecone-client

      - name: Get changed files
        id: changed-files
        run: |
          CHANGED_FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }} | grep -E '\.(py|js|ts|jsx|tsx|java|go) | tr '\n' ' ')
          echo "CHANGED_FILES=$CHANGED_FILES" >> $GITHUB_ENV
          
      - name: Generate code review
        run: |
          python -c "
          import os
          import openai
          import pinecone
          
          # 初期化
          client = openai.OpenAI(api_key='${{ secrets.OPENAI_API_KEY }}')
          pinecone.init(
              api_key='${{ secrets.PINECONE_API_KEY }}',
              environment='${{ secrets.PINECONE_ENVIRONMENT }}'
          )
          index = pinecone.Index('devin-code-index')
          
          def search_similar_code(file_content, top_k=3):
              # ファイル内容をエンベディングに変換
              response = client.embeddings.create(
                  input=file_content,
                  model='text-embedding-3-small'
              )
              embedding = response.data[0].embedding
              
              # Pineconeで類似検索
              results = index.query(
                  vector=embedding,
                  top_k=top_k,
                  include_metadata=True
              )
              
              return results
          
          # 変更されたファイルを処理
          changed_files = os.environ.get('CHANGED_FILES', '').split()
          
          review_comments = []
          
          for file_path in changed_files:
              try:
                  with open(file_path, 'r', encoding='utf-8') as f:
                      file_content = f.read()
                      
                  # 似たようなコードを検索
                  similar_results = search_similar_code(file_content)
                  
                  # レビューコメントを生成
                  similar_code_context = []
                  for match in similar_results['matches']:
                      metadata = match['metadata']
                      similar_file = metadata.get('file_path', 'Unknown file')
                      similar_code_context.append(f'- {similar_file} (similarity: {match[\"score\"]:.2f})')
                  
                  if similar_code_context:
                      comment = f'## Devin AI Code Review: {file_path}\\n\\n'
                      comment += '### Similar files in codebase:\\n'
                      comment += '\\n'.join(similar_code_context) + '\\n\\n'
                      comment += 'Please review if this implementation follows our coding standards and patterns.\\n'
                      
                      review_comments.append(comment)
                      
              except Exception as e:
                  print(f'Error processing {file_path}: {e}')
          
          # PR全体のレビューコメントを作成
          if review_comments:
              full_comment = '# Devin AI Code Review\\n\\n'
              full_comment += 'Based on similar code in our codebase, here are some files to compare your changes with:\\n\\n'
              full_comment += '\\n\\n'.join(review_comments)
              
              with open('pr_comment.md', 'w') as f:
                  f.write(full_comment)
          "
          
      - name: Comment on PR
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v6
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const fs = require('fs');
            try {
              const comment = fs.readFileSync('pr_comment.md', 'utf8');
              if (comment) {
                github.rest.issues.createComment({
                  issue_number: context.issue.number,
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  body: comment
                });
              }
            } catch (error) {
              console.log('No review comment file found');
            }