ltcai 0.1.3 → 0.1.8

package/tests/integration/test_api.py

@@ -0,0 +1,94 @@
+"""Integration tests for FastAPI endpoints.
+
+Run against a live server:  pytest tests/integration/ --base-url http://localhost:8899
+Default base URL falls back to http://localhost:8899 if flag not provided.
+"""
+import os
+import pytest
+import httpx
+
+BASE_URL = os.environ.get("LTCAI_TEST_BASE_URL", "http://localhost:8899")
+
+
+def _session_cookie() -> dict:
+    """Return session cookie if LTCAI_TEST_SESSION env var is set, else empty dict."""
+    sid = os.environ.get("LTCAI_TEST_SESSION", "")
+    return {"session_id": sid} if sid else {}
+
+
+@pytest.fixture(scope="session")
+def client():
+    with httpx.Client(base_url=BASE_URL, cookies=_session_cookie(), timeout=15) as c:
+        yield c
+
+
+# ---------------------------------------------------------------------------
+# Health / Info
+# ---------------------------------------------------------------------------
+
+def test_health(client):
+    r = client.get("/health")
+    assert r.status_code == 200
+    data = r.json()
+    assert "status" in data
+
+
+def test_mode_endpoint(client):
+    r = client.get("/mode")
+    assert r.status_code == 200
+    data = r.json()
+    assert "model" in data or "mode" in data
+
+
+def test_runtime_features(client):
+    r = client.get("/runtime_features")
+    assert r.status_code == 200
+
+
+# ---------------------------------------------------------------------------
+# Local filesystem endpoints
+# ---------------------------------------------------------------------------
+
+def test_local_list_home(client):
+    r = client.get("/local/list", params={"path": "~"})
+    # 200 if authenticated, 401/403 if no session
+    assert r.status_code in (200, 401, 403)
+
+
+def test_local_list_requires_auth(client):
+    """Without a session cookie the endpoint must reject the request."""
+    r = httpx.get(f"{BASE_URL}/local/list", params={"path": "~"}, timeout=10)
+    assert r.status_code in (401, 403)
+
+
+def test_local_serve_missing_file(client):
+    r = client.get("/local/serve", params={"path": "/nonexistent_lattice_ai_test_xyz.txt"})
+    assert r.status_code in (400, 401, 403, 404)
+
+
+# ---------------------------------------------------------------------------
+# /tools/read_document
+# ---------------------------------------------------------------------------
+
+def test_read_document_missing(client):
+    r = client.post("/tools/read_document", json={"path": "/nonexistent_lattice_ai_doc.txt"})
+    assert r.status_code in (400, 401, 403, 404, 422)
+
+
+# ---------------------------------------------------------------------------
+# /chat — smoke test (no model required)
+# ---------------------------------------------------------------------------
+
+def test_chat_requires_message(client):
+    r = client.post("/chat", json={})
+    # Missing message → 422 validation error or 401 unauth
+    assert r.status_code in (401, 403, 422)
+
+
+# ---------------------------------------------------------------------------
+# /agent — smoke test
+# ---------------------------------------------------------------------------
+
+def test_agent_requires_task(client):
+    r = client.post("/agent", json={})
+    assert r.status_code in (401, 403, 422)

package/tests/unit/test_tools.py

@@ -0,0 +1,127 @@
+"""Unit tests for tools.py core functions."""
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from tools import local_list, local_read, local_write, read_document, ToolError
+
+
+# ---------------------------------------------------------------------------
+# local_list
+# ---------------------------------------------------------------------------
+
+def test_local_list_returns_items(tmp_path):
+    (tmp_path / "a.txt").write_text("hello")
+    (tmp_path / "sub").mkdir()
+    result = local_list(str(tmp_path))
+    names = [i["name"] for i in result["items"]]
+    assert "a.txt" in names
+    assert "sub" in names
+
+
+def test_local_list_dirs_before_files(tmp_path):
+    (tmp_path / "z_file.txt").write_text("x")
+    (tmp_path / "a_dir").mkdir()
+    result = local_list(str(tmp_path))
+    types = [i["type"] for i in result["items"]]
+    assert types[0] == "directory"
+
+
+def test_local_list_nonexistent_raises(tmp_path):
+    with pytest.raises(ToolError):
+        local_list(str(tmp_path / "does_not_exist"))
+
+
+def test_local_list_file_raises(tmp_path):
+    f = tmp_path / "file.txt"
+    f.write_text("x")
+    with pytest.raises(ToolError):
+        local_list(str(f))
+
+
+# ---------------------------------------------------------------------------
+# local_read
+# ---------------------------------------------------------------------------
+
+def test_local_read_text_file(tmp_path):
+    f = tmp_path / "hello.txt"
+    f.write_text("hello world")
+    result = local_read(str(f))
+    assert "hello world" in result["content"]
+    assert result["path"] == str(f)
+
+
+def test_local_read_missing_file_raises(tmp_path):
+    with pytest.raises(ToolError):
+        local_read(str(tmp_path / "missing.txt"))
+
+
+def test_local_read_tilde_expansion(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    f = tmp_path / "testfile.txt"
+    f.write_text("tilde test")
+    result = local_read("~/testfile.txt")
+    assert "tilde test" in result["content"]
+
+
+def test_local_read_returns_size(tmp_path):
+    f = tmp_path / "sized.txt"
+    f.write_text("abc")
+    result = local_read(str(f))
+    assert result["size"] == 3
+
+
+# ---------------------------------------------------------------------------
+# local_write
+# ---------------------------------------------------------------------------
+
+def test_local_write_creates_file(tmp_path):
+    target = tmp_path / "out.txt"
+    result = local_write(str(target), "new content")
+    assert target.read_text() == "new content"
+    assert "bytes" in result
+
+
+def test_local_write_overwrites_file(tmp_path):
+    target = tmp_path / "out.txt"
+    target.write_text("old")
+    local_write(str(target), "new")
+    assert target.read_text() == "new"
+
+
+def test_local_write_creates_parent_dirs(tmp_path):
+    target = tmp_path / "deep" / "nested" / "file.txt"
+    local_write(str(target), "deep write")
+    assert target.exists()
+
+
+def test_local_write_returns_path(tmp_path):
+    target = tmp_path / "x.txt"
+    result = local_write(str(target), "hi")
+    assert result["path"] == str(target)
+
+
+# ---------------------------------------------------------------------------
+# read_document
+# ---------------------------------------------------------------------------
+
+def test_read_document_plain_text(tmp_path):
+    f = tmp_path / "doc.txt"
+    f.write_text("plain text content")
+    result = read_document(str(f))
+    assert "plain text content" in result.get("text", "") or "plain text content" in str(result)
+
+
+def test_read_document_missing_file_raises(tmp_path):
+    with pytest.raises(ToolError):
+        read_document(str(tmp_path / "missing.pdf"))
+
+
+def test_read_document_csv(tmp_path):
+    f = tmp_path / "data.csv"
+    f.write_text("col1,col2\n1,2\n3,4\n")
+    result = read_document(str(f))
+    # should not raise; returns some text content
+    assert result is not None

package/tools.py

@@ -8,6 +8,7 @@ workspace.
 
 import base64
 import os
+import platform
 import re
 import shlex
 import socket
@@ -18,6 +19,8 @@ from html.parser import HTMLParser
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+_PLATFORM = platform.system()  # "Darwin" | "Windows" | "Linux"
+
 from p_reinforce import BRAIN_DIR, STRUCTURE
 
 # ── Computer Use ──────────────────────────────────────────────────────────────
@@ -43,12 +46,19 @@ def computer_screenshot() -> Dict[str, Any]:
     with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
         tmp = tmp_file.name
     try:
-        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()}")
+        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)
@@ -69,11 +79,17 @@ def computer_screenshot() -> Dict[str, Any]:
 
 
 def computer_open_app(app: str = "Google Chrome") -> Dict[str, Any]:
-    """macOS 앱을 실행하거나 앞으로 가져옵니다."""
+    """앱을 실행하거나 앞으로 가져옵니다 (macOS/Windows/Linux)."""
     app = str(app or "Google Chrome").strip()
     if not app:
         raise ToolError("앱 이름이 필요합니다.")
-    r = subprocess.run(["open", "-a", app], capture_output=True, timeout=10, check=False)
+    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}")
@@ -81,18 +97,24 @@ def computer_open_app(app: str = "Google Chrome") -> Dict[str, Any]:
 
 
 def computer_open_url(url: str, app: str = "Google Chrome") -> Dict[str, Any]:
-    """URL을 지정한 macOS 앱으로 엽니다."""
+    """URL을 브라우저로 엽니다 (macOS/Windows/Linux)."""
     url = str(url or "").strip()
-    app = str(app or "Google Chrome").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
-    r = subprocess.run(["open", "-a", app, url], capture_output=True, timeout=10, check=False)
+    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, "url": 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]:
@@ -216,7 +238,19 @@ ALLOWED_COMMANDS = {
 }
 
 BUILD_SCRIPT_NAMES = {"build", "compile", "typecheck", "test"}
-DEPLOY_SCRIPT_NAMES = {"deploy", "preview", "release"}
+DEPLOY_SCRIPT_NAMES = {
+    "deploy",
+    "preview",
+    "release",
+    "package",
+    "dist",
+    "make",
+    "build:installer",
+    "build:pkg",
+    "build:exe",
+    "package:mac",
+    "package:win",
+}
 
 ALLOWED_GIT_SUBCOMMANDS = {"status", "diff", "log", "show"}
 
@@ -443,6 +477,126 @@ def preview_url(path: str = "index.html") -> Dict[str, Any]:
     }
 
 
+def create_web_project(path: str, framework: str = "react", template: str = "vite") -> Dict[str, Any]:
+    framework = str(framework or "").strip().lower()
+    template = str(template or "").strip().lower()
+    if framework != "react" or template != "vite":
+        raise ToolError("Only React + Vite template is currently supported.")
+    if not path:
+        raise ToolError("Project path is required.")
+
+    root = _resolve_path(path)
+    root.mkdir(parents=True, exist_ok=True)
+
+    files = {
+        "package.json": json.dumps(
+            {
+                "name": Path(path).name.replace(" ", "-").lower() or "vite-react-app",
+                "private": True,
+                "version": "0.0.0",
+                "type": "module",
+                "scripts": {
+                    "dev": "vite",
+                    "build": "vite build",
+                    "preview": "vite preview",
+                },
+                "dependencies": {
+                    "react": "^18.3.1",
+                    "react-dom": "^18.3.1",
+                },
+                "devDependencies": {
+                    "@vitejs/plugin-react": "^4.3.1",
+                    "vite": "^5.4.0",
+                },
+            },
+            ensure_ascii=False,
+            indent=2,
+        ) + "\n",
+        "index.html": """<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite React App</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
+""",
+        "vite.config.js": """import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+})
+""",
+        "README.md": """# Vite React App
+
+## Run
+
+```bash
+npm install
+npm run dev
+```
+
+## Build
+
+```bash
+npm run build
+npm run preview
+```
+""",
+        "src/main.jsx": """import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+""",
+        "src/App.jsx": """import { useState } from 'react'
+
+export default function App() {
+  const [count, setCount] = useState(0)
+  return (
+    <main style={{ maxWidth: 680, margin: '48px auto', fontFamily: 'system-ui, sans-serif' }}>
+      <h1>Vite + React</h1>
+      <p>Starter generated by Lattice AI agent.</p>
+      <button onClick={() => setCount((c) => c + 1)}>count is {count}</button>
+    </main>
+  )
+}
+""",
+        "src/index.css": """* { box-sizing: border-box; }
+body { margin: 0; background: #f6f7fb; color: #111; }
+button { padding: 10px 14px; border-radius: 10px; border: 1px solid #d6d6d6; background: #fff; cursor: pointer; }
+""",
+    }
+
+    created: List[str] = []
+    total_bytes = 0
+    for rel_path, content in files.items():
+        target = (root / rel_path).resolve()
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+        created.append(_relative(target))
+        total_bytes += target.stat().st_size
+
+    return {
+        "path": _relative(root),
+        "framework": framework,
+        "template": template,
+        "created_files": created,
+        "file_count": len(created),
+        "bytes": total_bytes,
+    }
+
+
 def _safe_filename(name: str, suffix: str) -> str:
     base = Path(name or f"artifact{suffix}").name
     if not base.lower().endswith(suffix):
@@ -1075,6 +1229,8 @@ def execute_tool(action: str, args: Dict[str, Any]) -> Dict[str, Any]:
         return create_pptx(args.get("title", ""), slides, args.get("filename", "presentation.pptx"))
     if action == "create_pdf":
         return create_pdf(args.get("title", ""), args.get("body", ""), args.get("filename", "document.pdf"))
+    if action == "create_web_project":
+        return create_web_project(args.get("path", ""), args.get("framework", "react"), args.get("template", "vite"))
     if action == "local_list":
         return local_list(args["path"])
     if action == "local_read":