answer42 0.2.0__py3-none-any.whl

mcp_1c/recorder.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import base64
+import html
+import json
+import os
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class RecordingSession:
+    active: bool = False
+    output_dir: Path = Path("build/recordings/session")
+    display: str = ""
+    window: bool = False
+    frames_dir: Path = Path("build/recordings/session/frames")
+    slides_dir: Path = Path("build/recordings/session/slides")
+    events: list[dict[str, Any]] = field(default_factory=list)
+
+    def start(self, output_dir: str, display: str = "", window: bool = False) -> dict[str, Any]:
+        self.active = True
+        self.output_dir = Path(output_dir)
+        self.display = display
+        self.window = window
+        self.frames_dir = self.output_dir / "frames"
+        self.slides_dir = self.output_dir / "slides"
+        self.events = []
+        self.frames_dir.mkdir(parents=True, exist_ok=True)
+        self.slides_dir.mkdir(parents=True, exist_ok=True)
+        # MP4/GIF generation is intentionally unsupported. Remove stale files
+        # from older runs so evidence directories reflect current outputs only.
+        for obsolete in ("recording.mp4", "recording.gif"):
+            try:
+                (self.output_dir / obsolete).unlink()
+            except FileNotFoundError:
+                pass
+            except OSError:
+                pass
+        return {"active": True, "output_dir": str(self.output_dir)}
+
+    def stop(self) -> dict[str, Any]:
+        self.active = False
+        manifest = self.output_dir / "manifest.json"
+        manifest.parent.mkdir(parents=True, exist_ok=True)
+        manifest.write_text(json.dumps({"events": self.events}, ensure_ascii=False, indent=2), encoding="utf-8")
+        media = self.build_media()
+        return {"active": False, "output_dir": str(self.output_dir), "events": len(self.events), **media}
+
+    def capture(self, screenshot_func, action: str, params: dict[str, Any], result: Any, *, screenshot: bool = True) -> dict[str, Any] | None:
+        if not self.active:
+            return None
+        index = len(self.events) + 1
+        slide = self.slides_dir / f"{index:03d}_{safe_name(action)}.svg"
+        safe_params = redact(params)
+        safe_result = redact(result)
+        frame = self.frames_dir / f"{index:03d}_{safe_name(action)}.png"
+        if screenshot:
+            try:
+                screenshot_func(str(frame), self.window, self.display)
+            except Exception as exc:
+                event = {"index": index, "action": action, "params": params, "result": summarize(result), "screenshot_error": str(exc)}
+                self.events.append(event)
+                return event
+            slide.write_text(make_slide_svg(frame, action, safe_params, safe_result, index), encoding="utf-8")
+        else:
+            slide.write_text(make_text_slide_svg(action, safe_params, safe_result, index), encoding="utf-8")
+        event = {
+            "index": index,
+            "action": action,
+            "params": safe_params,
+            "result": summarize(safe_result),
+            "slide": str(slide),
+        }
+        if screenshot:
+            event["frame"] = str(frame)
+        else:
+            event["text_only"] = True
+        self.events.append(event)
+        return event
+
+    def build_media(self) -> dict[str, Any]:
+        slides = sorted(self.slides_dir.glob("*.svg"))
+        if not slides:
+            return {"pdf": ""}
+        pdf = self.output_dir / "recording.pdf"
+        html_deck = self.output_dir / "recording.html"
+        html_deck.write_text(make_html_deck(slides), encoding="utf-8")
+        browser = first_existing(["google-chrome", "chromium", "chromium-browser", "chrome.exe", "msedge.exe"])
+        if browser:
+            run([
+                browser,
+                "--headless=new",
+                "--no-sandbox",
+                "--disable-gpu",
+                f"--print-to-pdf={pdf.resolve()}",
+                str(html_deck.resolve()),
+            ], timeout=240)
+        if not pdf.exists():
+            converter_names = ["magick", "magick.exe"] if os.name == "nt" else ["magick", "convert"]
+            converter = first_existing(converter_names)
+            if converter:
+                run([converter, *map(str, slides), str(pdf)], timeout=240)
+        if html_deck.exists():
+            try:
+                html_deck.unlink()
+            except OSError:
+                pass
+        return {"pdf": str(pdf) if pdf.exists() else ""}
+
+
+def make_html_deck(slides: list[Path]) -> str:
+    pages = []
+    for slide in slides:
+        data = slide.read_text(encoding="utf-8")
+        pages.append(f'<section class="page">{data}</section>')
+    return '''<!doctype html>
+<html><head><meta charset="utf-8"><style>
+@page { size: 16in 9in; margin: 0; }
+html, body { margin: 0; padding: 0; background: #111827; }
+.page { width: 16in; height: 9in; page-break-after: always; overflow: hidden; }
+.page svg { width: 16in; height: 9in; display: block; }
+</style></head><body>''' + "\n".join(pages) + "</body></html>"
+
+
+def run(args: list[str], timeout: int = 180) -> None:
+    try:
+        subprocess.run(args, check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout)
+    except Exception:
+        pass
+
+
+def first_existing(names: list[str]) -> str:
+    from shutil import which
+    for name in names:
+        path = which(name)
+        if path:
+            return path
+    if os.name == "nt":
+        env_paths = [
+            os.getenv("ProgramFiles"),
+            os.getenv("ProgramFiles(x86)"),
+            os.getenv("LocalAppData"),
+        ]
+        candidates = []
+        for root in filter(None, env_paths):
+            base = Path(str(root))
+            candidates.extend([
+                base / "Google/Chrome/Application/chrome.exe",
+                base / "Microsoft/Edge/Application/msedge.exe",
+                base / "Programs/Microsoft VS Code/chrome.exe",
+            ])
+        for candidate in candidates:
+            if candidate.exists():
+                return str(candidate)
+    return ""
+
+
+SENSITIVE_KEYS = {"password", "pwd", "pass", "secret", "token", "authorization", "auth"}
+
+
+def redact(value: Any) -> Any:
+    if isinstance(value, dict):
+        result = {}
+        for key, item in value.items():
+            if str(key).lower() in SENSITIVE_KEYS or "password" in str(key).lower():
+                result[key] = "***"
+            else:
+                result[key] = redact(item)
+        return result
+    if isinstance(value, list):
+        return [redact(item) for item in value]
+    return value
+
+
+def safe_name(value: str) -> str:
+    result = "".join(ch if ch.isalnum() or ch in "._-" else "_" for ch in value)[:80]
+    return result or "action"
+
+
+def summarize(value: Any, limit: int = 900) -> str:
+    try:
+        text = json.dumps(value, ensure_ascii=False, default=str)
+    except Exception:
+        text = str(value)
+    return text if len(text) <= limit else text[:limit] + "…"
+
+
+def make_slide_svg(frame: Path, action: str, params: dict[str, Any], result: Any, index: int) -> str:
+    data = base64.b64encode(frame.read_bytes()).decode("ascii")
+    param_text = summarize(params, 700)
+    result_text = summarize(result, 900)
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return f'''<svg xmlns="http://www.w3.org/2000/svg" width="1920" height="1080" viewBox="0 0 1920 1080">
+  <rect width="1920" height="1080" fill="#111827"/>
+  <rect x="24" y="24" width="1344" height="1032" rx="18" fill="#0b1220"/>
+  <image x="48" y="48" width="1296" height="972" href="data:image/png;base64,{data}" preserveAspectRatio="xMidYMid meet"/>
+  <rect x="1392" y="24" width="504" height="1032" rx="18" fill="#f8fafc"/>
+  <text x="1424" y="78" font-family="Arial" font-size="28" font-weight="700" fill="#111827">#{index} {html.escape(action)}</text>
+  <text x="1424" y="116" font-family="Arial" font-size="16" fill="#64748b">{html.escape(now)}</text>
+  <text x="1424" y="170" font-family="Arial" font-size="22" font-weight="700" fill="#0f172a">Параметры</text>
+  {multiline_text(param_text, 1424, 204, 440, 17, '#334155')}
+  <text x="1424" y="550" font-family="Arial" font-size="22" font-weight="700" fill="#0f172a">Результат</text>
+  {multiline_text(result_text, 1424, 584, 440, 17, '#334155')}
+</svg>'''
+
+
+def make_text_slide_svg(action: str, params: dict[str, Any], result: Any, index: int) -> str:
+    param_text = summarize(params, 1800)
+    result_text = summarize(result, 3000)
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return f'''<svg xmlns="http://www.w3.org/2000/svg" width="1920" height="1080" viewBox="0 0 1920 1080">
+  <rect width="1920" height="1080" fill="#111827"/>
+  <rect x="48" y="40" width="1824" height="1000" rx="18" fill="#f8fafc"/>
+  <text x="88" y="96" font-family="Arial" font-size="32" font-weight="700" fill="#111827">#{index} {html.escape(action)}</text>
+  <text x="88" y="134" font-family="Arial" font-size="16" fill="#64748b">{html.escape(now)} · text-only MCP evidence (no UI screenshot)</text>
+  <text x="88" y="196" font-family="Arial" font-size="24" font-weight="700" fill="#0f172a">Параметры</text>
+  {multiline_text(param_text, 88, 232, 1720, 18, '#334155', max_lines=14)}
+  <text x="88" y="552" font-family="Arial" font-size="24" font-weight="700" fill="#0f172a">Результат</text>
+  {multiline_text(result_text, 88, 588, 1720, 18, '#334155', max_lines=20)}
+</svg>'''
+
+
+def multiline_text(text: str, x: int, y: int, width: int, font_size: int, color: str, max_lines: int = 22) -> str:
+    chars = max(20, width // int(font_size * 0.55))
+    lines: list[str] = []
+    for raw in text.splitlines() or [""]:
+        s = raw
+        while len(s) > chars:
+            lines.append(s[:chars])
+            s = s[chars:]
+        lines.append(s)
+    out = []
+    for i, line in enumerate(lines[:max_lines]):
+        out.append(f'<text x="{x}" y="{y + i * (font_size + 5)}" font-family="Arial" font-size="{font_size}" fill="{color}">{html.escape(line)}</text>')
+    return "\n  ".join(out)

mcp_1c/release_helper.py

@@ -0,0 +1,83 @@
+"""Release helper for Answer42 source checkouts."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+from pathlib import Path
+
+SEMVER_RE = re.compile(r"^\d+\.\d+\.\d+(?:[A-Za-z0-9_.+-]*)?$")
+
+
+def _run(cmd: list[str], *, dry_run: bool) -> None:
+    print("+", " ".join(cmd))
+    if not dry_run:
+        subprocess.run(cmd, check=True)
+
+
+def _git_output(args: list[str]) -> str:
+    return subprocess.check_output(["git", *args], text=True).strip()
+
+
+def _replace_version(pyproject: Path, version: str) -> bool:
+    text = pyproject.read_text(encoding="utf-8")
+    pattern = r'(?m)^version\s*=\s*"([^"]+)"\s*$'
+    match = re.search(pattern, text)
+    if not match:
+        raise RuntimeError(f"Could not find project.version in {pyproject}")
+    if match.group(1) == version:
+        return False
+    new_text, count = re.subn(pattern, f'version = "{version}"', text, count=1)
+    if count != 1:
+        raise RuntimeError(f"Could not replace project.version in {pyproject}")
+    pyproject.write_text(new_text, encoding="utf-8")
+    return True
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Bump pyproject.toml version, commit, tag and push to trigger PyPI release CI"
+    )
+    parser.add_argument("version", help="Version without leading v, e.g. 0.2.1")
+    parser.add_argument("--remote", default="origin", help="Git remote to push. Default: origin")
+    parser.add_argument("--branch", default="HEAD", help="Branch/ref to push. Default: HEAD")
+    parser.add_argument("--dry-run", action="store_true", help="Print commands without executing them")
+    parser.add_argument("--no-push", action="store_true", help="Create commit/tag locally but do not push")
+    parser.add_argument("--allow-dirty", action="store_true", help="Allow unrelated uncommitted changes")
+    args = parser.parse_args(argv)
+
+    version = args.version.removeprefix("v")
+    if not SEMVER_RE.match(version):
+        raise SystemExit(f"Invalid version {args.version!r}; expected e.g. 0.2.1")
+    tag = f"v{version}"
+
+    repo_root = Path(_git_output(["rev-parse", "--show-toplevel"]))
+    pyproject = repo_root / "pyproject.toml"
+    status = _git_output(["status", "--porcelain"])
+    if status and not args.allow_dirty:
+        raise SystemExit(
+            "Working tree is not clean. Commit/stash changes first, or pass --allow-dirty.\n" + status
+        )
+    existing_tags = _git_output(["tag", "--list", tag])
+    if existing_tags:
+        raise SystemExit(f"Tag already exists: {tag}")
+
+    print(f"Bumping {pyproject} to {version}")
+    changed = True
+    if not args.dry_run:
+        changed = _replace_version(pyproject, version)
+    else:
+        print(f"+ update {pyproject}: version = {version!r}")
+
+    if changed:
+        _run(["git", "add", str(pyproject.relative_to(repo_root))], dry_run=args.dry_run)
+        _run(["git", "commit", "-m", f"Release {tag}"], dry_run=args.dry_run)
+    else:
+        print(f"Version is already {version}; tagging current HEAD without a version commit.")
+    _run(["git", "tag", "-a", tag, "-m", f"Release {tag}"], dry_run=args.dry_run)
+    if not args.no_push:
+        _run(["git", "push", args.remote, args.branch], dry_run=args.dry_run)
+        _run(["git", "push", args.remote, tag], dry_run=args.dry_run)
+        print("CI will publish PyPI package and create GitLab Release from the pushed tag.")
+    return 0