my-test-wldnjs2 0.1.0__tar.gz

my_test_wldnjs2-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14.3

my_test_wldnjs2-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: my-test-wldnjs2
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.14.3
+Requires-Dist: beautifulsoup4>=4.15.0
+Requires-Dist: build>=1.5.0
+Requires-Dist: mcp[cli]>=1.28.0
+Requires-Dist: pypdf2>=3.0.1
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: python-pptx>=1.0.2
+Requires-Dist: requests>=2.34.2
+Requires-Dist: twine>=6.2.0

my_test_wldnjs2-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "my-test-wldnjs2"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14.3"
+dependencies = [
+    "beautifulsoup4>=4.15.0",
+    "build>=1.5.0",
+    "mcp[cli]>=1.28.0",
+    "pypdf2>=3.0.1",
+    "python-docx>=1.2.0",
+    "python-pptx>=1.0.2",
+    "requests>=2.34.2",
+    "twine>=6.2.0",
+]
+
+[project.scripts]
+my-test-wldnjs2 = "my_test_wldnjs2.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

my_test_wldnjs2-0.1.0/src/my_test_wldnjs2/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from my-test-wldnjs2!")

my_test_wldnjs2-0.1.0/src/my_test_wldnjs2/server.py

@@ -0,0 +1,264 @@
+import os
+import sys  # 추가됨: 표준 에러(stderr) 출력을 위해 필요
+import sqlite3
+import concurrent.futures
+from datetime import datetime, timedelta
+import PyPDF2
+import docx
+import pptx
+from mcp.server.fastmcp import FastMCP
+
+# Initialize FastMCP server
+mcp = FastMCP("local_file_explorer")
+
+# 데이터베이스 경로 설정 (사용자 홈 디렉토리에 숨김 파일로 저장)
+DB_PATH = os.path.expanduser("~/.local_explorer_index.db")
+
+def get_default_dir() -> str:
+    """사용자의 기본 문서 폴더 경로를 반환합니다."""
+    return os.path.join(os.path.expanduser("~"), "Documents")
+
+def init_db():
+    """SQLite FTS5 및 메타데이터 테이블 초기화"""
+    with sqlite3.connect(DB_PATH) as conn:
+        # 파일 메타데이터 관리용 테이블
+        conn.execute('''
+            CREATE TABLE IF NOT EXISTS file_meta (
+                file_path TEXT PRIMARY KEY,
+                last_modified REAL
+            )
+        ''')
+        # 내용 전문 검색용 FTS5 가상 테이블
+        conn.execute('''
+            CREATE VIRTUAL TABLE IF NOT EXISTS file_content
+            USING fts5(file_path UNINDEXED, content)
+        ''')
+
+def extract_text_safe(file_path: str, ext: str, max_pages: int = 30) -> str:
+    """안전하게 텍스트를 추출하며 일정량 이상 넘어가면 조기 종료합니다."""
+    text = ""
+    try:
+        if ext == '.pdf':
+            with open(file_path, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                for i, page in enumerate(reader.pages):
+                    if i >= max_pages: break # 조기 종료
+                    extracted = page.extract_text()
+                    if extracted: text += extracted + " "
+        elif ext == '.docx':
+            doc = docx.Document(file_path)
+            for i, para in enumerate(doc.paragraphs):
+                if i >= max_pages * 15: break # 대략적인 문단 수 제한
+                text += para.text + " "
+        elif ext == '.pptx':
+            prs = pptx.Presentation(file_path)
+            for i, slide in enumerate(prs.slides):
+                if i >= max_pages: break
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + " "
+        elif ext == '.txt':
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                text = f.read(50000) # 최대 5만 자 제한
+    except Exception as e:
+        # 파일 읽기 실패 시 stderr로 로그를 남겨 MCP 통신 방해를 막음
+        print(f"Error reading {file_path}: {e}", file=sys.stderr)
+        return ""
+    return text
+
+
+@mcp.tool()
+def update_file_index(directory: str = None, extensions: list[str] = ['.pdf', '.docx', '.pptx', '.txt']) -> dict:
+    """
+    [관리 도구] 새로 추가되거나 수정된 파일의 텍스트를 추출하여 빠른 검색을 위해 인덱싱합니다.
+    검색을 수행하기 전에 문서 폴더의 내용을 최신화할 때 사용하세요.
+    """
+    search_dir = directory or get_default_dir()
+    init_db()
+
+    files_to_process = []
+    
+    # 1. 변경된 파일 스캔 (증분 인덱싱 대상 찾기)
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        for root, _, files in os.walk(search_dir):
+            for file in files:
+                ext = os.path.splitext(file)[1].lower()
+                if ext in extensions:
+                    file_path = os.path.join(root, file)
+                    try:
+                        mtime = os.path.getmtime(file_path)
+                        cursor.execute('SELECT last_modified FROM file_meta WHERE file_path = ?', (file_path,))
+                        row = cursor.fetchone()
+                        # DB에 없거나, 파일 수정 날짜가 더 최신인 경우만 처리 대상
+                        if row is None or row[0] < mtime:
+                            files_to_process.append((file_path, ext, mtime))
+                    except OSError:
+                        continue
+
+    if not files_to_process:
+        return {"status": "success", "message": "모든 파일이 이미 최신 상태입니다.", "indexed_count": 0}
+
+    indexed_count = 0
+    skipped_count = 0
+
+    # 2. ProcessPoolExecutor를 이용한 장애 격리(Isolation) 및 타임아웃
+    with concurrent.futures.ProcessPoolExecutor() as executor:
+        future_to_file = {
+            executor.submit(extract_text_safe, path, ext): (path, mtime)
+            for path, ext, mtime in files_to_process
+        }
+
+        with sqlite3.connect(DB_PATH) as conn:
+            for future in concurrent.futures.as_completed(future_to_file):
+                file_path, mtime = future_to_file[future]
+                try:
+                    # 10초 이상 걸리는 파일은 강제 중단 (타임아웃)
+                    content = future.result(timeout=10.0)
+                    
+                    if content.strip():
+                        # 트랜잭션: 메타데이터 업데이트 & FTS5 인덱스 재입력
+                        conn.execute('INSERT OR REPLACE INTO file_meta (file_path, last_modified) VALUES (?, ?)', (file_path, mtime))
+                        conn.execute('DELETE FROM file_content WHERE file_path = ?', (file_path,))
+                        conn.execute('INSERT INTO file_content (file_path, content) VALUES (?, ?)', (file_path, content))
+                        indexed_count += 1
+                    else:
+                        skipped_count += 1
+                except concurrent.futures.TimeoutError:
+                    skipped_count += 1
+                    # 타임아웃된 파일이 매번 다시 시도되어 시스템을 늦추지 않도록 현재 mtime만 갱신 (무시 처리)
+                    conn.execute('INSERT OR REPLACE INTO file_meta (file_path, last_modified) VALUES (?, ?)', (file_path, mtime))
+                except Exception as e:
+                    print(f"Error processing {file_path}: {e}", file=sys.stderr)
+                    skipped_count += 1
+
+    return {
+        "status": "success", 
+        "indexed_count": indexed_count, 
+        "skipped_count": skipped_count,
+        "message": f"{indexed_count}개 파일 인덱싱 완료, {skipped_count}개 스킵(타임아웃/오류)."
+    }
+
+
+@mcp.tool()
+def search_indexed_contents(keyword: str) -> list[dict]:
+    """
+    [핵심 검색 도구] 인덱싱된 내용을 기반으로 키워드가 포함된 파일과 매칭된 문맥(스니펫)을 즉시 검색합니다.
+    주의: 이 도구를 사용하기 전에 update_file_index가 실행되어 있어야 가장 정확합니다.
+    """
+    init_db()
+    results = []
+    
+    try:
+        with sqlite3.connect(DB_PATH) as conn:
+            cursor = conn.cursor()
+            # snippet을 이용한 매칭 문장 추출 및 관련도 랭킹 정렬
+            safe_keyword = f'"{keyword}"'
+            query = '''
+                SELECT 
+                    file_path, 
+                    snippet(file_content, 1, '[', ']', '...', 15) as context_snippet
+                FROM file_content
+                WHERE content MATCH ?
+                ORDER BY rank
+                LIMIT 15
+            '''
+            cursor.execute(query, (safe_keyword,))
+            
+            for row in cursor.fetchall():
+                file_path, context = row
+                results.append({
+                    "file_name": os.path.basename(file_path),
+                    "file_path": file_path,
+                    "matched_context": context # 검색어가 포함된 핵심 문장
+                })
+    except Exception as e:
+        print(f"DB search error: {e}", file=sys.stderr)
+        return [{"error": f"DB 검색 중 오류 발생 (먼저 인덱싱을 진행해주세요): {str(e)}"}]
+
+    return results if results else [{"message": "해당 키워드를 포함하는 문서를 찾을 수 없습니다."}]
+
+
+@mcp.tool()
+def search_local_files(directory: str = None, filename_keyword: str = None, extensions: list[str] = None, days_ago: int = None) -> list[dict]:
+    """파일명, 확장자, 수정 날짜를 기준으로 파일을 검색합니다."""
+    search_dir = directory or get_default_dir()
+    results = []
+    
+    cutoff_time = None
+    if days_ago is not None:
+        cutoff_time = datetime.now() - timedelta(days=days_ago)
+
+    try:
+        for root, _, files in os.walk(search_dir):
+            for file in files:
+                if filename_keyword and filename_keyword.lower() not in file.lower():
+                    continue
+                if extensions:
+                    ext = os.path.splitext(file)[1].lower()
+                    if ext not in [e.lower() for e in extensions]:
+                        continue
+                
+                file_path = os.path.join(root, file)
+                
+                try:
+                    mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
+                    if cutoff_time and mtime < cutoff_time:
+                        continue
+                    
+                    results.append({
+                        "file_name": file,
+                        "file_path": file_path,
+                        "modified_date": mtime.strftime("%Y-%m-%d %H:%M:%S"),
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                    })
+                except OSError:
+                    continue
+    except Exception as e:
+        return [{"error": f"디렉토리 접근 중 오류 발생: {str(e)}"}]
+        
+    return sorted(results, key=lambda x: x["modified_date"], reverse=True)
+
+
+@mcp.tool()
+def analyze_disk_usage(directory: str = None, top_n: int = 10) -> list[dict]:
+    """특정 디렉토리 내의 하위 폴더와 파일들의 용량을 분석하여 가장 큰 항목들을 반환합니다."""
+    search_dir = directory or get_default_dir()
+    usage_data = []
+
+    try:
+        for item in os.listdir(search_dir):
+            item_path = os.path.join(search_dir, item)
+            total_size = 0
+            
+            try:
+                if os.path.isfile(item_path):
+                    total_size = os.path.getsize(item_path)
+                elif os.path.isdir(item_path):
+                    for root, _, files in os.walk(item_path):
+                        for f in files:
+                            f_path = os.path.join(root, f)
+                            if not os.path.islink(f_path):
+                                total_size += os.path.getsize(f_path)
+                
+                usage_data.append({
+                    "name": item,
+                    "path": item_path,
+                    "is_dir": os.path.isdir(item_path),
+                    "size_mb": round(total_size / (1024 * 1024), 2)
+                })
+            except OSError:
+                continue
+    except Exception as e:
+        return [{"error": f"분석 중 오류 발생: {str(e)}"}]
+
+    return sorted(usage_data, key=lambda x: x["size_mb"], reverse=True)[:top_n]
+
+
+def main() -> None:
+    # 수정점: 클라이언트의 JSON 파싱을 방해하지 않도록 stderr로 출력 방향 설정
+    print("Starting Advanced Local File Explorer MCP server...", file=sys.stderr)
+    mcp.run(transport='stdio')
+
+if __name__ == "__main__":
+    main()