revengelibrary 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

revengelibrary/ide_server.py

@@ -0,0 +1,480 @@
+from __future__ import annotations
+
+import argparse
+import json
+import mimetypes
+import os
+import shutil
+import subprocess
+import tempfile
+import threading
+import webbrowser
+from dataclasses import dataclass, field
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from .agents import DEFAULT_AGENT, build_agent_memory_file, get_agent, list_agents
+from .chat import (
+    APIError,
+    DEFAULT_MODEL,
+    DEFAULT_OPENROUTER_API_KEY,
+    FreeNeuroChatClient,
+)
+
+IDE_DIR = Path(__file__).resolve().parent / "ide"
+HIDDEN_SKIP = {".git", "venv", ".venv", "__pycache__", "build", "dist"}
+
+
+@dataclass
+class IDEState:
+    root_dir: Path
+    api_key: str
+    default_model: str
+    default_memory_file: str
+    clients: dict[tuple[str, str, str, str], FreeNeuroChatClient] = field(
+        default_factory=dict
+    )
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+    def get_client(
+        self,
+        agent_name: str,
+        model: str,
+        memory_file: str | None = None,
+        system_prompt: str | None = None,
+    ) -> FreeNeuroChatClient:
+        agent = get_agent(agent_name)
+        chosen_model = model or self.default_model
+        prompt = system_prompt or agent.system_prompt
+
+        base_memory_file = memory_file or self.default_memory_file
+        scoped_memory_file = build_agent_memory_file(base_memory_file, agent.name) or ""
+
+        key = (agent.name, chosen_model, scoped_memory_file, prompt)
+        with self.lock:
+            client = self.clients.get(key)
+            if client is not None:
+                return client
+
+            client = FreeNeuroChatClient(
+                api_key=self.api_key,
+                model=chosen_model,
+                system_prompt=prompt,
+                memory_file=scoped_memory_file or None,
+            )
+            self.clients[key] = client
+            return client
+
+
+def _json_response(
+    handler: BaseHTTPRequestHandler,
+    payload: dict[str, Any],
+    status: int = HTTPStatus.OK,
+) -> None:
+    raw = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("Content-Type", "application/json; charset=utf-8")
+    handler.send_header("Content-Length", str(len(raw)))
+    handler.end_headers()
+    handler.wfile.write(raw)
+
+
+def _text_response(
+    handler: BaseHTTPRequestHandler,
+    content: bytes,
+    content_type: str,
+    status: int = HTTPStatus.OK,
+) -> None:
+    handler.send_response(status)
+    handler.send_header("Content-Type", content_type)
+    handler.send_header("Content-Length", str(len(content)))
+    handler.end_headers()
+    handler.wfile.write(content)
+
+
+def _read_json(handler: BaseHTTPRequestHandler) -> dict[str, Any]:
+    raw_len = handler.headers.get("Content-Length", "0")
+    try:
+        length = int(raw_len)
+    except ValueError:
+        return {}
+    if length <= 0:
+        return {}
+    raw = handler.rfile.read(length)
+    try:
+        data = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _safe_project_path(root: Path, rel_path: str) -> Path:
+    rel = Path(rel_path)
+    if rel.is_absolute():
+        raise ValueError("Absolute paths are not allowed.")
+    candidate = (root / rel).resolve()
+    resolved_root = root.resolve()
+    if candidate != resolved_root and resolved_root not in candidate.parents:
+        raise ValueError("Path escapes project root.")
+    return candidate
+
+
+def _collect_files(root: Path) -> list[str]:
+    result: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [name for name in dirnames if name not in HIDDEN_SKIP]
+        base = Path(dirpath)
+        for filename in filenames:
+            if filename.endswith((".pyc", ".pyo")):
+                continue
+            if filename in {".DS_Store"}:
+                continue
+            file_path = base / filename
+            rel = file_path.relative_to(root).as_posix()
+            result.append(rel)
+    result.sort()
+    return result
+
+
+def _normalize_text(content: str) -> str:
+    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+    cleaned_lines = [line.rstrip() for line in normalized.split("\n")]
+    return "\n".join(cleaned_lines).rstrip() + "\n"
+
+
+def _run_external_formatter(
+    command: list[str],
+    source: str,
+    suffix: str,
+) -> str | None:
+    temp_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=suffix,
+            encoding="utf-8",
+            delete=False,
+        ) as tmp:
+            tmp.write(source)
+            temp_path = Path(tmp.name)
+
+        result = subprocess.run(
+            [*command, str(temp_path)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return None
+
+        return temp_path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    finally:
+        if temp_path is not None:
+            temp_path.unlink(missing_ok=True)
+
+
+def _format_source(path: Path, content: str) -> str:
+    suffix = path.suffix.lower()
+
+    if suffix == ".json":
+        try:
+            payload = json.loads(content)
+            return json.dumps(payload, ensure_ascii=False, indent=2) + "\n"
+        except json.JSONDecodeError:
+            return _normalize_text(content)
+
+    if suffix == ".py":
+        if shutil.which("ruff"):
+            formatted = _run_external_formatter(["ruff", "format"], content, ".py")
+            if formatted is not None:
+                return formatted
+        if shutil.which("black"):
+            formatted = _run_external_formatter(["black", "-q"], content, ".py")
+            if formatted is not None:
+                return formatted
+        return _normalize_text(content)
+
+    if suffix in {".js", ".ts", ".tsx", ".jsx", ".css", ".html"}:
+        if shutil.which("prettier"):
+            formatted = _run_external_formatter(["prettier", "--write"], content, suffix)
+            if formatted is not None:
+                return formatted
+        return _normalize_text(content)
+
+    return _normalize_text(content)
+
+
+def _load_asset(relative_name: str) -> tuple[bytes, str]:
+    asset_path = IDE_DIR / relative_name
+    if not asset_path.exists():
+        raise FileNotFoundError(relative_name)
+    content = asset_path.read_bytes()
+    content_type, _ = mimetypes.guess_type(asset_path.as_posix())
+    return content, content_type or "application/octet-stream"
+
+
+def _make_handler(state: IDEState) -> type[BaseHTTPRequestHandler]:
+    class IDEHandler(BaseHTTPRequestHandler):
+        server_version = "revengelibrary-ide/1.0"
+
+        def log_message(self, format: str, *args: Any) -> None:  # noqa: A003
+            return
+
+        def do_GET(self) -> None:  # noqa: N802
+            parsed = urlparse(self.path)
+            path = parsed.path
+            query = parse_qs(parsed.query)
+
+            if path == "/api/config":
+                payload = {
+                    "root_name": state.root_dir.name,
+                    "default_model": state.default_model,
+                    "default_memory_file": state.default_memory_file,
+                    "default_agent": DEFAULT_AGENT,
+                    "agents": [
+                        {"name": item.name, "title": item.title}
+                        for item in list_agents()
+                    ],
+                }
+                _json_response(self, payload)
+                return
+
+            if path == "/api/files":
+                files = _collect_files(state.root_dir)
+                _json_response(self, {"files": files})
+                return
+
+            if path == "/api/file":
+                file_values = query.get("path") or []
+                if not file_values:
+                    _json_response(
+                        self,
+                        {"error": "Missing query parameter: path"},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+                try:
+                    target = _safe_project_path(state.root_dir, file_values[0])
+                    content = target.read_text(encoding="utf-8")
+                except (OSError, ValueError) as exc:
+                    _json_response(
+                        self,
+                        {"error": str(exc)},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+                _json_response(self, {"path": file_values[0], "content": content})
+                return
+
+            if path == "/" or path == "/index.html":
+                content, content_type = _load_asset("index.html")
+                _text_response(self, content, content_type)
+                return
+            if path == "/app.css":
+                content, content_type = _load_asset("styles.css")
+                _text_response(self, content, content_type)
+                return
+            if path == "/app.js":
+                content, content_type = _load_asset("app.js")
+                _text_response(self, content, content_type)
+                return
+
+            _json_response(
+                self,
+                {"error": f"Not found: {path}"},
+                status=HTTPStatus.NOT_FOUND,
+            )
+
+        def do_POST(self) -> None:  # noqa: N802
+            path = urlparse(self.path).path
+            body = _read_json(self)
+
+            if path == "/api/file":
+                rel_path = str(body.get("path", "")).strip()
+                content = str(body.get("content", ""))
+                if not rel_path:
+                    _json_response(
+                        self,
+                        {"error": "Field 'path' is required"},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+
+                try:
+                    target = _safe_project_path(state.root_dir, rel_path)
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    target.write_text(content, encoding="utf-8")
+                except (OSError, ValueError) as exc:
+                    _json_response(
+                        self,
+                        {"error": str(exc)},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+
+                _json_response(self, {"ok": True, "path": rel_path})
+                return
+
+            if path == "/api/format":
+                rel_path = str(body.get("path", "")).strip()
+                if not rel_path:
+                    _json_response(
+                        self,
+                        {"error": "Field 'path' is required"},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+
+                try:
+                    target = _safe_project_path(state.root_dir, rel_path)
+                    input_content = body.get("content")
+                    source = (
+                        str(input_content)
+                        if input_content is not None
+                        else target.read_text(encoding="utf-8")
+                    )
+                    formatted = _format_source(target, source)
+                    target.write_text(formatted, encoding="utf-8")
+                except (OSError, ValueError) as exc:
+                    _json_response(
+                        self,
+                        {"error": str(exc)},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+
+                _json_response(self, {"ok": True, "path": rel_path, "content": formatted})
+                return
+
+            if path == "/api/chat":
+                message = str(body.get("message", "")).strip()
+                agent_name = str(body.get("agent", DEFAULT_AGENT))
+                model = str(body.get("model", state.default_model))
+                memory_file = body.get("memory_file")
+                system_prompt = body.get("system_prompt")
+
+                if not message:
+                    _json_response(
+                        self,
+                        {"error": "Field 'message' is required"},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+
+                try:
+                    client = state.get_client(
+                        agent_name=agent_name,
+                        model=model,
+                        memory_file=str(memory_file) if memory_file else None,
+                        system_prompt=str(system_prompt) if system_prompt else None,
+                    )
+                    reply = client.send(message)
+                except (ValueError, APIError) as exc:
+                    _json_response(
+                        self,
+                        {"error": str(exc)},
+                        status=HTTPStatus.BAD_REQUEST,
+                    )
+                    return
+                except Exception as exc:  # noqa: BLE001
+                    _json_response(
+                        self,
+                        {"error": f"Unexpected chat error: {exc}"},
+                        status=HTTPStatus.INTERNAL_SERVER_ERROR,
+                    )
+                    return
+
+                _json_response(
+                    self,
+                    {
+                        "reply": reply,
+                        "agent": agent_name,
+                        "model": client.model,
+                        "memory_file": client.memory_file,
+                    },
+                )
+                return
+
+            _json_response(
+                self,
+                {"error": f"Not found: {path}"},
+                status=HTTPStatus.NOT_FOUND,
+            )
+
+    return IDEHandler
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="revengelibrary-ide",
+        description="Run local IDE-style interface for revengelibrary.",
+    )
+    parser.add_argument("--host", default="127.0.0.1", help="Bind host.")
+    parser.add_argument("--port", default=8765, type=int, help="Bind port.")
+    parser.add_argument(
+        "--root",
+        default=os.getcwd(),
+        help="Project root shown in the IDE.",
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.getenv("OPENROUTER_API_KEY", DEFAULT_OPENROUTER_API_KEY),
+        help="OpenRouter API key.",
+    )
+    parser.add_argument(
+        "--model",
+        default=DEFAULT_MODEL,
+        help="Default chat model.",
+    )
+    parser.add_argument(
+        "--memory-file",
+        default=".revide_memory",
+        help="Base memory file name for IDE chat sessions.",
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Do not auto-open browser.",
+    )
+    return parser
+
+
+def main() -> int:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    root_dir = Path(args.root).expanduser().resolve()
+    if not root_dir.exists() or not root_dir.is_dir():
+        parser.error(f"Invalid --root: {root_dir}")
+
+    state = IDEState(
+        root_dir=root_dir,
+        api_key=args.api_key or DEFAULT_OPENROUTER_API_KEY,
+        default_model=args.model,
+        default_memory_file=str((root_dir / args.memory_file).resolve()),
+    )
+    handler_cls = _make_handler(state)
+    server = ThreadingHTTPServer((args.host, args.port), handler_cls)
+
+    url = f"http://{args.host}:{args.port}"
+    print(f"revengelibrary IDE: {url}")
+    print(f"root: {root_dir}")
+    if not args.no_browser:
+        webbrowser.open(url)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{revengelibrary-0.1.5.dist-info → revengelibrary-0.1.7.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: revengelibrary
-Version: 0.1.5
-Summary: Python chat library and CLI for free LLM models via OpenRouter.
+Version: 0.1.7
+Summary: Не нейросеть
 Author: revengebibliotek contributors
 License: MIT
 Project-URL: Homepage, https://github.com/example/revengelibrary

revengelibrary-0.1.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+revengelibrary/__init__.py,sha256=gCrIdVqm-vWoL5KmjtJQr5-W44RXHkrUt2udhvnBT5I,448
+revengelibrary/agents.py,sha256=nF--yecnFXaaNayi5I-41j0KDy-k64tqogRfw5re0wA,2675
+revengelibrary/chat.py,sha256=1UyJ9HZNea_oglsYMVqg3VdR2ASJvn4IPTBdUjNQ03k,7542
+revengelibrary/cli.py,sha256=ztrcFN9Zs5JIOFZ17j2K624BWpAffyYQ-Fj9ReDcqtU,3363
+revengelibrary/ide_server.py,sha256=ORPN2iSkMsA3dRv5y5NGEigA0aY2kog6yEWUvDj9Mlg,15961
+revengelibrary/memory_store.json,sha256=N1F-Xz3GaBn2H1p7uKzhkhKCQV8QVR0t76XD6wmFtXA,3
+revengelibrary/ide/app.js,sha256=ulYjtCALokdG3EsFHxP2oQe1XCfcpNx24RhTLciTiHo,9614
+revengelibrary/ide/index.html,sha256=4aC007wOnnB0qbh0Yu5JLPDL41pSDJ4LXpjzGDP9vu4,3207
+revengelibrary/ide/styles.css,sha256=7BJPxEJ9ppn9OE81W3OW0ydmb_OOLTN8l8itlytSPAY,6858
+revengelibrary-0.1.7.dist-info/licenses/LICENSE,sha256=UgqQ8UtVfIOP8-clGkGAylmb9AUbT4-Ue49N_WjIpi4,1073
+revengelibrary-0.1.7.dist-info/METADATA,sha256=qQ-5nOdCnC1ijicsulU54rODc6kH9F76JCXROCRuaoc,822
+revengelibrary-0.1.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+revengelibrary-0.1.7.dist-info/entry_points.txt,sha256=z5tzRCdH6_7gF5IQjgwFu2pQImVJayK7V5DDFmmk-d8,111
+revengelibrary-0.1.7.dist-info/top_level.txt,sha256=gfUsAxA-IgliQakMoupLAAjrTEYtUJurH5n29eHhUBE,15
+revengelibrary-0.1.7.dist-info/RECORD,,

{revengelibrary-0.1.5.dist-info → revengelibrary-0.1.7.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 revengelibrary = revengelibrary.cli:main
+revengelibrary-ide = revengelibrary.ide_server:main

revengelibrary-0.1.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-revengelibrary/__init__.py,sha256=HWDxVkOjWf65-SM4JIm0p3aNyDoEByCuCjTJCiFgBD4,299
-revengelibrary/chat.py,sha256=a1crCvwW9L3w3YYstE_OFtCM4khrPoGtr8eZFL6-EnQ,7374
-revengelibrary/cli.py,sha256=zllHMGN8EHJCSzMI5kpT8wk2-h9sD_38ysJ9zY6NxO0,2543
-revengelibrary/memory_store.json,sha256=N1F-Xz3GaBn2H1p7uKzhkhKCQV8QVR0t76XD6wmFtXA,3
-revengelibrary-0.1.5.dist-info/licenses/LICENSE,sha256=UgqQ8UtVfIOP8-clGkGAylmb9AUbT4-Ue49N_WjIpi4,1073
-revengelibrary-0.1.5.dist-info/METADATA,sha256=bqiA6Mi7yblgWF42hGOXMO2gDgcExiPNUIEL-U4O6gQ,862
-revengelibrary-0.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-revengelibrary-0.1.5.dist-info/entry_points.txt,sha256=299WMDffRchuwIlqEIjW-DwHYkBvRZQwGjiASIVofYE,59
-revengelibrary-0.1.5.dist-info/top_level.txt,sha256=gfUsAxA-IgliQakMoupLAAjrTEYtUJurH5n29eHhUBE,15
-revengelibrary-0.1.5.dist-info/RECORD,,