answer42 0.2.0__py3-none-any.whl

mcp_1c/skill_installer.py

@@ -0,0 +1,127 @@
+"""Install packaged Answer42 skills into popular agent skill directories."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.resources
+import shutil
+from pathlib import Path
+
+PACKAGED_SKILLS = ("answer42", "answer42-rag")
+
+AGENT_SKILL_DIRS = {
+    # OpenClaw workspace skills.
+    "openclaw": Path("~/.openclaw/workspace/skills"),
+    # Claude Code / Claude Desktop style user skills directory.
+    "claude": Path("~/.claude/skills"),
+    # Best-effort conventional locations for agents that do not expose a single
+    # portable skill standard yet. Users can always pass --target-dir explicitly.
+    "codex": Path("~/.codex/skills"),
+    "opencode": Path("~/.config/opencode/skills"),
+    "pi": Path("~/.pi/skills"),
+    "hermes": Path("~/.hermes/skills"),
+}
+
+
+def _copy_tree(src: Path, dst: Path, *, force: bool, dry_run: bool) -> str:
+    existed = dst.exists()
+    if existed:
+        if not force:
+            return "skipped-exists"
+        if not dry_run:
+            shutil.rmtree(dst)
+    if not dry_run:
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(src, dst)
+    return "updated" if existed else "installed"
+
+
+def install_skills(
+    *,
+    agents: list[str],
+    target_dir: Path | None,
+    skills: list[str],
+    force: bool,
+    dry_run: bool,
+) -> list[dict[str, str]]:
+    selected_skills = skills or list(PACKAGED_SKILLS)
+    unknown_skills = sorted(set(selected_skills) - set(PACKAGED_SKILLS))
+    if unknown_skills:
+        raise ValueError(f"Unknown packaged skill(s): {', '.join(unknown_skills)}")
+
+    targets: list[tuple[str, Path]] = []
+    if target_dir is not None:
+        targets.append(("custom", target_dir.expanduser()))
+    for agent in agents:
+        if agent == "all":
+            targets.extend((name, path.expanduser()) for name, path in AGENT_SKILL_DIRS.items())
+            continue
+        path = AGENT_SKILL_DIRS.get(agent)
+        if path is None:
+            raise ValueError(
+                f"Unknown agent {agent!r}. Known: {', '.join(sorted(AGENT_SKILL_DIRS))}, all"
+            )
+        targets.append((agent, path.expanduser()))
+    if not targets:
+        targets.append(("openclaw", AGENT_SKILL_DIRS["openclaw"].expanduser()))
+
+    results: list[dict[str, str]] = []
+    root = importlib.resources.files("mcp_1c.assets").joinpath("skills")
+    with importlib.resources.as_file(root) as root_path:
+        for skill in selected_skills:
+            src = root_path / skill
+            if not src.exists():
+                raise FileNotFoundError(f"Packaged skill not found: {skill}")
+            for agent, base_dir in targets:
+                dst = base_dir / skill
+                status = _copy_tree(src, dst, force=force, dry_run=dry_run)
+                results.append(
+                    {
+                        "agent": agent,
+                        "skill": skill,
+                        "path": str(dst),
+                        "status": "would-" + status if dry_run else status,
+                    }
+                )
+    return results
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Install packaged Answer42 skills")
+    parser.add_argument(
+        "--agent",
+        action="append",
+        choices=[*sorted(AGENT_SKILL_DIRS), "all"],
+        help="Agent preset to install into. Can be passed multiple times. Default: openclaw.",
+    )
+    parser.add_argument(
+        "--target-dir",
+        type=Path,
+        help="Custom skills directory. Use this for agents with non-standard or project-local paths.",
+    )
+    parser.add_argument(
+        "--skill",
+        action="append",
+        choices=list(PACKAGED_SKILLS),
+        help="Packaged skill to install. Can be passed multiple times. Default: all packaged skills.",
+    )
+    parser.add_argument("--no-overwrite", action="store_true", help="Skip skills that already exist.")
+    parser.add_argument("--dry-run", action="store_true", help="Print planned changes without writing files.")
+    parser.add_argument("--list-agents", action="store_true", help="Print known agent presets and exit.")
+    args = parser.parse_args(argv)
+
+    if args.list_agents:
+        for name, path in sorted(AGENT_SKILL_DIRS.items()):
+            print(f"{name}: {path.expanduser()}")
+        return 0
+
+    results = install_skills(
+        agents=args.agent or [],
+        target_dir=args.target_dir,
+        skills=args.skill or [],
+        force=not args.no_overwrite,
+        dry_run=args.dry_run,
+    )
+    for item in results:
+        print(f"{item['status']}: {item['agent']}:{item['skill']} -> {item['path']}")
+    return 0

mcp_1c/window_control.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import ctypes
+import ctypes.wintypes
+import os
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class WindowControlResult:
+    ok: bool
+    method: str
+    title: str = ""
+    geometry: dict[str, int] | None = None
+    candidates: list[dict[str, Any]] | None = None
+    error: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "method": self.method,
+            "title": self.title,
+            "geometry": self.geometry or {},
+            "candidates": self.candidates or [],
+            "error": self.error,
+        }
+
+
+def maximize_test_client_window(
+    title_contains: str = "",
+    display: str | None = None,
+    width: int | None = None,
+    height: int | None = None,
+) -> dict[str, Any]:
+    """Maximize/resize a 1C test-client window.
+
+    Priority: Windows WinAPI on Windows; wmctrl -> xdotool -> python-xlib on X11.
+    This function controls only window geometry; it doesn't click or type in the application.
+    """
+    if os.name == "nt":
+        return _maximize_with_winapi(title_contains, width, height).as_dict()
+
+    env = os.environ.copy()
+    if display:
+        env["DISPLAY"] = display
+    display = env.get("DISPLAY", "")
+
+    for fn in (_maximize_with_wmctrl, _maximize_with_xdotool, _maximize_with_xlib):
+        result = fn(title_contains=title_contains, display=display, width=width, height=height, env=env)
+        if result.ok:
+            return result.as_dict()
+        last = result
+    return last.as_dict()
+
+
+def active_1c_window_geometry(title_contains: str = "") -> dict[str, int] | None:
+    """Return best visible 1C window geometry on Windows, or None elsewhere."""
+    if os.name != "nt":
+        return None
+    chosen = _find_windows_1c_window(title_contains)
+    if not chosen:
+        return None
+    return chosen.get("geometry")
+
+
+def _screen_size(display: str, env: dict[str, str]) -> tuple[int, int]:
+    try:
+        out = subprocess.check_output(["xdpyinfo", "-display", display], env=env, text=True, stderr=subprocess.DEVNULL)
+        for line in out.splitlines():
+            if "dimensions:" in line:
+                part = line.split("dimensions:", 1)[1].strip().split()[0]
+                w, h = part.split("x")
+                return int(w), int(h)
+    except Exception:
+        pass
+    return 1920, 1080
+
+
+def _maximize_with_wmctrl(title_contains: str, display: str, width: int | None, height: int | None, env: dict[str, str]) -> WindowControlResult:
+    if not shutil.which("wmctrl"):
+        return WindowControlResult(False, "wmctrl", error="wmctrl not installed")
+    try:
+        sw, sh = (width, height) if width and height else _screen_size(display, env)
+        out = subprocess.check_output(["wmctrl", "-l"], env=env, text=True)
+        candidates=[]
+        chosen=None
+        for line in out.splitlines():
+            parts=line.split(None, 3)
+            if len(parts) < 4:
+                continue
+            wid, _, _, title = parts
+            item={"id": wid, "title": title}
+            candidates.append(item)
+            if _title_matches(title, title_contains):
+                chosen=item
+        if chosen is None:
+            return WindowControlResult(False, "wmctrl", candidates=candidates, error="window not found")
+        wid=chosen["id"]
+        subprocess.check_call(["wmctrl", "-i", "-r", wid, "-b", "remove,maximized_vert,maximized_horz"], env=env)
+        subprocess.check_call(["wmctrl", "-i", "-r", wid, "-e", f"0,0,0,{sw},{sh}"], env=env)
+        subprocess.check_call(["wmctrl", "-i", "-r", wid, "-b", "add,maximized_vert,maximized_horz"], env=env)
+        return WindowControlResult(True, "wmctrl", title=chosen["title"], geometry={"x":0,"y":0,"width":sw,"height":sh}, candidates=candidates)
+    except Exception as e:
+        return WindowControlResult(False, "wmctrl", error=str(e))
+
+
+def _maximize_with_xdotool(title_contains: str, display: str, width: int | None, height: int | None, env: dict[str, str]) -> WindowControlResult:
+    if not shutil.which("xdotool"):
+        return WindowControlResult(False, "xdotool", error="xdotool not installed")
+    try:
+        sw, sh = (width, height) if width and height else _screen_size(display, env)
+        pattern = title_contains or ".*"
+        ids = subprocess.check_output(["xdotool", "search", "--name", pattern], env=env, text=True).split()
+        if not ids:
+            return WindowControlResult(False, "xdotool", error="window not found")
+        wid=ids[-1]
+        title = subprocess.check_output(["xdotool", "getwindowname", wid], env=env, text=True).strip()
+        subprocess.check_call(["xdotool", "windowsize", wid, str(sw), str(sh)], env=env)
+        subprocess.check_call(["xdotool", "windowmove", wid, "0", "0"], env=env)
+        subprocess.check_call(["xdotool", "windowactivate", wid], env=env)
+        return WindowControlResult(True, "xdotool", title=title, geometry={"x":0,"y":0,"width":sw,"height":sh})
+    except Exception as e:
+        return WindowControlResult(False, "xdotool", error=str(e))
+
+
+def _title_matches(title: str, title_contains: str) -> bool:
+    if title_contains and title_contains.lower() not in title.lower():
+        return False
+    if "Конфигурация" in title:
+        return False
+    return any(s in title for s in ["DEV-AREA", "Начальная", "Приложения", "1С:Предприятие", "ЭмФешн", "Время создания"])
+
+
+def _maximize_with_xlib(title_contains: str, display: str, width: int | None, height: int | None, env: dict[str, str]) -> WindowControlResult:
+    try:
+        from Xlib import X, display as xdisplay
+        disp = xdisplay.Display(display or None)
+        root = disp.screen().root
+        sw = width or disp.screen().width_in_pixels
+        sh = height or disp.screen().height_in_pixels
+        candidates=[]
+        def walk(win):
+            yield win
+            try:
+                children = win.query_tree().children
+            except Exception:
+                return
+            for child in children:
+                yield from walk(child)
+        def get_name(win):
+            for atom_name in ("_NET_WM_NAME", "WM_NAME"):
+                try:
+                    prop=win.get_full_property(disp.intern_atom(atom_name), X.AnyPropertyType)
+                    if prop and prop.value is not None:
+                        value=prop.value
+                        if isinstance(value, bytes):
+                            return value.decode("utf-8", "ignore")
+                        try:
+                            return bytes(value).decode("utf-8", "ignore")
+                        except Exception:
+                            return str(value)
+                except Exception:
+                    pass
+            return ""
+        chosen=None
+        for win in walk(root):
+            title=get_name(win)
+            if not title:
+                continue
+            try:
+                geo=win.get_geometry()
+            except Exception:
+                continue
+            if geo.width < 300 or geo.height < 200:
+                continue
+            item={"title": title, "width": geo.width, "height": geo.height}
+            candidates.append(item)
+            if _title_matches(title, title_contains):
+                chosen=(win, item)
+        if chosen is None:
+            return WindowControlResult(False, "xlib", candidates=candidates, error="window not found")
+        win,item=chosen
+        win.configure(x=0, y=0, width=sw, height=sh, border_width=0, stack_mode=X.Above)
+        try:
+            win.set_input_focus(X.RevertToParent, X.CurrentTime)
+        except Exception:
+            pass
+        win.map()
+        disp.sync()
+        time.sleep(0.2)
+        return WindowControlResult(True, "xlib", title=item["title"], geometry={"x":0,"y":0,"width":sw,"height":sh}, candidates=candidates)
+    except Exception as e:
+        return WindowControlResult(False, "xlib", error=str(e))
+
+
+def _find_windows_1c_window(title_contains: str = "") -> dict[str, Any] | None:
+    user32 = ctypes.windll.user32
+    candidates: list[dict[str, Any]] = []
+
+    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+
+    def callback(hwnd: int, _lparam: int) -> bool:
+        try:
+            if not user32.IsWindowVisible(hwnd):
+                return True
+            length = user32.GetWindowTextLengthW(hwnd)
+            if length <= 0:
+                return True
+            buf = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buf, length + 1)
+            title = buf.value
+            if not _title_matches(title, title_contains):
+                return True
+            rect = ctypes.wintypes.RECT()  # type: ignore[attr-defined]
+            if not user32.GetWindowRect(hwnd, ctypes.byref(rect)):
+                return True
+            width = int(rect.right - rect.left)
+            height = int(rect.bottom - rect.top)
+            if width < 300 or height < 150:
+                return True
+            priority = min(width * height // 10000, 50)
+            if "1С:Предприятие" in title:
+                priority += 50
+            if title and title not in {"1cv8c", "1cv8", "Конфигурация"}:
+                priority += 100
+            candidates.append({
+                "hwnd": hwnd,
+                "title": title,
+                "priority": priority,
+                "geometry": {"left": int(rect.left), "top": int(rect.top), "width": width, "height": height, "title": title},
+            })
+        except Exception:
+            pass
+        return True
+
+    try:
+        user32.EnumWindows(EnumWindowsProc(callback), 0)
+    except Exception:
+        return None
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: int(item.get("priority") or 0), reverse=True)
+    return candidates[0]
+
+
+def _maximize_with_winapi(title_contains: str, width: int | None, height: int | None) -> WindowControlResult:
+    try:
+        import ctypes.wintypes  # type: ignore  # noqa: F401
+
+        user32 = ctypes.windll.user32
+        chosen = _find_windows_1c_window(title_contains)
+        if chosen is None:
+            return WindowControlResult(False, "winapi", error="window not found")
+        hwnd = int(chosen["hwnd"])
+        screen_w = width or user32.GetSystemMetrics(0) or 1920
+        screen_h = height or user32.GetSystemMetrics(1) or 1080
+        user32.ShowWindow(hwnd, 9)  # SW_RESTORE
+        user32.MoveWindow(hwnd, 0, 0, int(screen_w), int(screen_h), True)
+        user32.ShowWindow(hwnd, 3)  # SW_MAXIMIZE
+        try:
+            user32.SetForegroundWindow(hwnd)
+        except Exception:
+            pass
+        return WindowControlResult(
+            True,
+            "winapi",
+            title=str(chosen.get("title") or ""),
+            geometry={"x": 0, "y": 0, "width": int(screen_w), "height": int(screen_h)},
+            candidates=[{"title": str(chosen.get("title") or ""), "hwnd": hwnd}],
+        )
+    except Exception as e:
+        return WindowControlResult(False, "winapi", error=str(e))