ltcai 3.4.0 → 3.5.0

package/tools/computer.py

@@ -0,0 +1,185 @@
+"""Computer-use tools: screenshots and native desktop control."""
+
+from __future__ import annotations
+
+import base64
+import os
+import platform
+import subprocess
+import time
+from typing import Any, Dict
+
+from tools import ToolError
+
+_PLATFORM = platform.system()
+
+
+# ── Computer Use ──────────────────────────────────────────────────────────────
+_CU_AVAILABLE = False
+_pyautogui = None
+
+def _init_computer_use():
+    global _CU_AVAILABLE, _pyautogui
+    try:
+        import pyautogui as _pag
+        _pag.FAILSAFE = True   # 마우스를 좌상단 코너로 이동하면 중단
+        _pag.PAUSE = 0.25
+        _pyautogui = _pag
+        _CU_AVAILABLE = True
+    except Exception:
+        pass
+
+_init_computer_use()
+
+
+def computer_screenshot() -> Dict[str, Any]:
+    """현재 화면 전체를 캡처하여 base64 PNG로 반환합니다."""
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
+        tmp = tmp_file.name
+    try:
+        if _PLATFORM == "Darwin":
+            r = subprocess.run(
+                ["screencapture", "-x", "-t", "png", tmp],
+                capture_output=True, timeout=10, check=False,
+            )
+            if r.returncode != 0:
+                raise ToolError(f"screencapture 실패: {r.stderr.decode()}")
+        elif _CU_AVAILABLE:
+            # Windows / Linux: use pyautogui screenshot
+            screenshot = _pyautogui.screenshot()
+            screenshot.save(tmp)
+        else:
+            raise ToolError("스크린샷 불가: macOS 전용 screencapture 또는 pyautogui 필요")
+        with open(tmp, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode()
+        size = os.path.getsize(tmp)
+        w, h = (_pyautogui.size() if _CU_AVAILABLE else (0, 0))
+        return {
+            "screenshot_b64": b64,
+            "format": "png",
+            "bytes": size,
+            "screen_width": int(w),
+            "screen_height": int(h),
+        }
+    finally:
+        try:
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+        except OSError:
+            pass
+
+
+def computer_open_app(app: str = "Google Chrome") -> Dict[str, Any]:
+    """앱을 실행하거나 앞으로 가져옵니다 (macOS/Windows/Linux)."""
+    app = str(app or "Google Chrome").strip()
+    if not app:
+        raise ToolError("앱 이름이 필요합니다.")
+    if _PLATFORM == "Darwin":
+        cmd = ["open", "-a", app]
+    elif _PLATFORM == "Windows":
+        cmd = ["cmd", "/c", "start", "", app]
+    else:
+        cmd = ["xdg-open", app]
+    r = subprocess.run(cmd, capture_output=True, timeout=10, check=False)
+    if r.returncode != 0:
+        err = r.stderr.decode("utf-8", errors="replace").strip()
+        raise ToolError(f"앱 열기 실패: {err or app}")
+    return {"action": "open_app", "app": app}
+
+
+def computer_open_url(url: str, app: str = "Google Chrome") -> Dict[str, Any]:
+    """URL을 브라우저로 엽니다 (macOS/Windows/Linux)."""
+    url = str(url or "").strip()
+    app = str(app or "").strip()
+    if not url:
+        raise ToolError("URL이 필요합니다.")
+    if "://" not in url and not url.startswith(("localhost", "127.0.0.1")):
+        url = "https://" + url
+    if _PLATFORM == "Darwin":
+        cmd = ["open", "-a", app, url] if app else ["open", url]
+    elif _PLATFORM == "Windows":
+        cmd = ["cmd", "/c", "start", "", url]
+    else:
+        cmd = ["xdg-open", url]
+    r = subprocess.run(cmd, capture_output=True, timeout=10, check=False)
+    if r.returncode != 0:
+        err = r.stderr.decode("utf-8", errors="replace").strip()
+        raise ToolError(f"URL 열기 실패: {err or url}")
+    return {"action": "open_url", "app": app or "default", "url": url}
+
+
+def computer_click(x: int, y: int, button: str = "left", double: bool = False) -> Dict[str, Any]:
+    """화면 좌표 (x, y)를 클릭합니다."""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    x, y = int(x), int(y)
+    if double:
+        _pyautogui.doubleClick(x, y)
+    elif button == "right":
+        _pyautogui.rightClick(x, y)
+    elif button == "middle":
+        _pyautogui.middleClick(x, y)
+    else:
+        _pyautogui.click(x, y)
+    return {"action": "click", "x": x, "y": y, "button": button, "double": double}
+
+
+def computer_type(text: str, interval: float = 0.04) -> Dict[str, Any]:
+    """현재 포커스된 위치에 텍스트를 입력합니다."""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    _pyautogui.write(str(text), interval=float(interval))
+    return {"action": "type", "text": (text[:60] + "...") if len(text) > 60 else text, "chars": len(text)}
+
+
+def computer_key(key: str) -> Dict[str, Any]:
+    """키보드 키를 누릅니다. 예: 'return', 'escape', 'command+c', 'tab'"""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    key = str(key)
+    if "+" in key:
+        _pyautogui.hotkey(*key.split("+"))
+    else:
+        _pyautogui.press(key)
+    return {"action": "key", "key": key}
+
+
+def computer_scroll(x: int, y: int, direction: str = "down", clicks: int = 3) -> Dict[str, Any]:
+    """화면 좌표에서 스크롤합니다."""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    x, y, clicks = int(x), int(y), int(clicks)
+    _pyautogui.moveTo(x, y)
+    amount = -clicks if direction == "down" else clicks
+    _pyautogui.scroll(amount)
+    return {"action": "scroll", "x": x, "y": y, "direction": direction, "clicks": clicks}
+
+
+def computer_move(x: int, y: int) -> Dict[str, Any]:
+    """마우스를 좌표로 이동합니다 (클릭 없음)."""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    _pyautogui.moveTo(int(x), int(y), duration=0.2)
+    return {"action": "move", "x": int(x), "y": int(y)}
+
+
+def computer_drag(x1: int, y1: int, x2: int, y2: int) -> Dict[str, Any]:
+    """(x1,y1)에서 (x2,y2)로 드래그합니다."""
+    if not _CU_AVAILABLE:
+        raise ToolError("pyautogui를 사용할 수 없습니다.")
+    _pyautogui.moveTo(int(x1), int(y1))
+    _pyautogui.dragTo(int(x2), int(y2), duration=0.35, button="left")
+    return {"action": "drag", "from": [int(x1), int(y1)], "to": [int(x2), int(y2)]}
+
+
+def computer_status() -> Dict[str, Any]:
+    """Computer Use 기능 사용 가능 여부를 확인합니다."""
+    if not _CU_AVAILABLE:
+        return {"available": False, "reason": "pyautogui not installed"}
+    w, h = _pyautogui.size()
+    return {
+        "available": True,
+        "screen_size": {"width": int(w), "height": int(h)},
+        "failsafe": _pyautogui.FAILSAFE,
+        "note": "macOS Accessibility 권한이 필요합니다 (시스템 설정 > 개인 정보 보호 > 손쉬운 사용)",
+    }

package/tools/documents.py

@@ -0,0 +1,243 @@
+"""Document generation (docx/xlsx/pptx/pdf) and extraction (read_document)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+from tools import (
+    ToolError,
+    _resolve_path,
+    _relative,
+    DOCUMENT_OUTPUT_DIR,
+    PRESENTATION_OUTPUT_DIR,
+    SPREADSHEET_OUTPUT_DIR,
+    PDF_OUTPUT_DIR,
+    DOCUMENT_MAX_READ_BYTES,
+    _CJK_FONT_CANDIDATES,
+    _SUPPORTED_READ_EXTENSIONS,
+)
+
+
+def _safe_filename(name: str, suffix: str) -> str:
+    base = Path(name or f"artifact{suffix}").name
+    if not base.lower().endswith(suffix):
+        base += suffix
+    safe = "".join(ch if ch.isalnum() or ch in ("-", "_", ".", " ") else "_" for ch in base).strip()
+    return safe or f"artifact{suffix}"
+
+
+def _body_to_str(body) -> str:
+    if isinstance(body, list):
+        return "\n\n".join(str(item) for item in body)
+    return str(body or "")
+
+
+def create_docx(title: str, body, filename: str = "document.docx") -> Dict[str, Any]:
+    try:
+        from docx import Document
+    except Exception as exc:
+        raise ToolError("python-docx is not installed. Run `pip install -r requirements.txt`.") from exc
+
+    output_dir = _resolve_path(DOCUMENT_OUTPUT_DIR)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target = output_dir / _safe_filename(filename, ".docx")
+
+    document = Document()
+    if title:
+        document.add_heading(str(title), level=1)
+    for block in _body_to_str(body).split("\n\n"):
+        text = block.strip()
+        if text:
+            document.add_paragraph(text)
+    document.save(target)
+    return {"path": _relative(target), "bytes": target.stat().st_size}
+
+
+def create_xlsx(rows: List[List[Any]], filename: str = "spreadsheet.xlsx", sheet_name: str = "Sheet1") -> Dict[str, Any]:
+    try:
+        from openpyxl import Workbook
+    except Exception as exc:
+        raise ToolError("openpyxl is not installed. Run `pip install -r requirements.txt`.") from exc
+
+    if not isinstance(rows, list) or not all(isinstance(row, list) for row in rows):
+        raise ToolError("Rows must be a list of lists.")
+
+    output_dir = _resolve_path(SPREADSHEET_OUTPUT_DIR)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target = output_dir / _safe_filename(filename, ".xlsx")
+
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = (sheet_name or "Sheet1")[:31]
+    for row in rows:
+        sheet.append(row)
+    workbook.save(target)
+    return {"path": _relative(target), "rows": len(rows), "bytes": target.stat().st_size}
+
+
+def create_pptx(title: str, slides: List[Dict[str, Any]], filename: str = "presentation.pptx") -> Dict[str, Any]:
+    try:
+        from pptx import Presentation
+    except Exception as exc:
+        raise ToolError("python-pptx is not installed. Run `pip install -r requirements.txt`.") from exc
+
+    output_dir = _resolve_path(PRESENTATION_OUTPUT_DIR)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target = output_dir / _safe_filename(filename, ".pptx")
+
+    presentation = Presentation()
+    first_layout = presentation.slide_layouts[0]
+    first = presentation.slides.add_slide(first_layout)
+    first.shapes.title.text = title or "Presentation"
+    first.placeholders[1].text = ""
+
+    content_layout = presentation.slide_layouts[1]
+    for slide_data in slides or []:
+        slide = presentation.slides.add_slide(content_layout)
+        slide.shapes.title.text = str(slide_data.get("title") or "Slide")
+        body = slide.placeholders[1].text_frame
+        body.clear()
+        bullets = slide_data.get("bullets") or []
+        if isinstance(bullets, str):
+            bullets = [bullets]
+        for index, bullet in enumerate(bullets):
+            paragraph = body.paragraphs[0] if index == 0 else body.add_paragraph()
+            paragraph.text = str(bullet)
+            paragraph.level = 0
+
+    presentation.save(target)
+    return {"path": _relative(target), "slides": len(presentation.slides), "bytes": target.stat().st_size}
+
+
+
+
+def create_pdf(title: str, body, filename: str = "document.pdf") -> Dict[str, Any]:
+    try:
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.units import mm
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+        from reportlab.pdfbase import pdfmetrics
+        from reportlab.pdfbase.ttfonts import TTFont
+    except Exception as exc:
+        raise ToolError("reportlab is not installed. Run `pip install reportlab`.") from exc
+
+    output_dir = _resolve_path(PDF_OUTPUT_DIR)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target = output_dir / _safe_filename(filename, ".pdf")
+
+    # CJK 폰트 등록
+    font_name = "Helvetica"
+    for font_path in _CJK_FONT_CANDIDATES:
+        if Path(font_path).exists():
+            try:
+                pdfmetrics.registerFont(TTFont("KoreanFont", font_path))
+                font_name = "KoreanFont"
+            except Exception:
+                pass
+            break
+
+    styles = getSampleStyleSheet()
+    title_style = ParagraphStyle("Title", fontName=font_name, fontSize=18, spaceAfter=8, leading=24)
+    body_style  = ParagraphStyle("Body",  fontName=font_name, fontSize=11, spaceAfter=6, leading=16)
+
+    story = []
+    if title:
+        story.append(Paragraph(str(title), title_style))
+        story.append(Spacer(1, 4 * mm))
+
+    for block in _body_to_str(body).split("\n\n"):
+        text = block.strip()
+        if text:
+            safe_text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            story.append(Paragraph(safe_text, body_style))
+            story.append(Spacer(1, 2 * mm))
+
+    doc = SimpleDocTemplate(str(target), pagesize=A4,
+                             leftMargin=20*mm, rightMargin=20*mm,
+                             topMargin=20*mm, bottomMargin=20*mm)
+    doc.build(story)
+    return {"path": _relative(target), "bytes": target.stat().st_size}
+
+
+def read_document(path: str) -> Dict[str, Any]:
+    """Extract text from PDF, DOCX, XLSX, PPTX, TXT, MD, CSV files."""
+    target = Path(path).expanduser().resolve()
+    if not target.exists():
+        raise ToolError(f"파일이 없습니다: {path}")
+    if not target.is_file():
+        raise ToolError(f"파일이 아닙니다: {path}")
+    if target.stat().st_size > DOCUMENT_MAX_READ_BYTES:
+        raise ToolError(f"파일이 너무 큽니다 ({target.stat().st_size:,} bytes).")
+
+    ext = target.suffix.lower()
+    if ext not in _SUPPORTED_READ_EXTENSIONS:
+        raise ToolError(f"지원하지 않는 형식입니다: {ext}. 지원: {', '.join(_SUPPORTED_READ_EXTENSIONS)}")
+
+    text = ""
+    meta: Dict[str, Any] = {"path": str(target), "ext": ext}
+
+    if ext == ".pdf":
+        try:
+            import pdfplumber
+            with pdfplumber.open(str(target)) as pdf:
+                meta["pages"] = len(pdf.pages)
+                text = "\n\n".join(
+                    (p.extract_text() or "") for p in pdf.pages
+                ).strip()
+        except Exception as exc:
+            raise ToolError(f"PDF 읽기 실패: {exc}") from exc
+
+    elif ext == ".docx":
+        try:
+            from docx import Document
+            doc = Document(str(target))
+            paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+            text = "\n\n".join(paragraphs)
+            meta["paragraphs"] = len(paragraphs)
+        except Exception as exc:
+            raise ToolError(f"DOCX 읽기 실패: {exc}") from exc
+
+    elif ext == ".xlsx":
+        try:
+            from openpyxl import load_workbook
+            wb = load_workbook(str(target), data_only=True)
+            rows_all = []
+            for ws in wb.worksheets:
+                rows_all.append(f"[Sheet: {ws.title}]")
+                for row in ws.iter_rows(values_only=True):
+                    cells = [str(c) if c is not None else "" for c in row]
+                    rows_all.append("\t".join(cells))
+            text = "\n".join(rows_all)
+            meta["sheets"] = len(wb.worksheets)
+        except Exception as exc:
+            raise ToolError(f"XLSX 읽기 실패: {exc}") from exc
+
+    elif ext == ".pptx":
+        try:
+            from pptx import Presentation
+            prs = Presentation(str(target))
+            slides_text = []
+            for i, slide in enumerate(prs.slides, 1):
+                parts = []
+                for shape in slide.shapes:
+                    if shape.has_text_frame:
+                        parts.append(shape.text_frame.text)
+                slides_text.append(f"[Slide {i}]\n" + "\n".join(parts))
+            text = "\n\n".join(slides_text)
+            meta["slides"] = len(prs.slides)
+        except Exception as exc:
+            raise ToolError(f"PPTX 읽기 실패: {exc}") from exc
+
+    elif ext in {".txt", ".md", ".csv"}:
+        try:
+            text = target.read_text(encoding="utf-8", errors="replace")
+        except Exception as exc:
+            raise ToolError(f"파일 읽기 실패: {exc}") from exc
+
+    meta["chars"] = len(text)
+    meta["preview"] = text[:500]
+    meta["content"] = text[:50_000]   # 50K char cap for context
+    return meta