answer42 0.2.0__py3-none-any.whl

mcp_1c/os_support.py

@@ -0,0 +1,224 @@
+"""Cross-platform OS helpers for Answer42 runtime.
+
+Keep platform-specific process, lock and filesystem defaults here so the
+higher-level MCP tools do not import POSIX-only modules on Windows.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator
+
+IS_WINDOWS = os.name == "nt"
+IS_POSIX = os.name == "posix"
+
+
+def default_data_dir() -> Path:
+    """Return the default Answer42 runtime data directory for this OS."""
+    override = os.getenv("ONEC_MCP_DATA_DIR")
+    if override:
+        return Path(override)
+    return Path(tempfile.gettempdir()) / "onec-mcp"
+
+
+def runtime_path(env_name: str, *parts: str) -> Path:
+    """Return an env-overridable path under the runtime data directory."""
+    override = os.getenv(env_name)
+    if override:
+        return Path(override)
+    return default_data_dir().joinpath(*parts)
+
+
+@contextmanager
+def file_lock(path: Path) -> Iterator[None]:
+    """Acquire an exclusive file lock on POSIX and Windows.
+
+    The implementation imports fcntl/msvcrt lazily so importing Answer42 on
+    Windows does not fail on the POSIX-only ``fcntl`` module.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a+b") as lock_file:
+        lock_file.seek(0)
+        if not lock_file.read(1):
+            lock_file.write(b"0")
+            lock_file.flush()
+        lock_file.seek(0)
+        if IS_WINDOWS:
+            import msvcrt  # type: ignore
+
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
+            try:
+                yield
+            finally:
+                lock_file.seek(0)
+                msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+        else:
+            import fcntl  # type: ignore
+
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+
+
+def subprocess_creation_kwargs(*, detached: bool = True) -> dict[str, object]:
+    """Return Popen kwargs for a separately controllable child process."""
+    if IS_WINDOWS:
+        flags = 0
+        if detached:
+            flags |= getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+        return {"creationflags": flags} if flags else {}
+    return {"start_new_session": True} if detached else {}
+
+
+def kill_process_tree(proc: subprocess.Popen | None, label: str, logger: logging.Logger | None = None) -> None:
+    """Terminate a subprocess tree in a cross-platform way."""
+    log = logger or logging.getLogger(__name__)
+    if proc is None:
+        return
+    try:
+        if proc.poll() is not None:
+            return
+    except Exception:
+        return
+
+    if IS_WINDOWS:
+        try:
+            subprocess.run(
+                ["taskkill", "/PID", str(proc.pid), "/T", "/F"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+                timeout=10,
+            )
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass
+            log.info("Stopped %s (pid=%s) via taskkill", label, proc.pid)
+            return
+        except Exception as exc:
+            log.debug("taskkill failed for %s (pid=%s): %s", label, proc.pid, exc)
+        try:
+            proc.terminate()
+            proc.wait(timeout=5)
+            log.info("Stopped %s (pid=%s) via terminate", label, proc.pid)
+            return
+        except Exception:
+            pass
+        try:
+            proc.kill()
+            proc.wait(timeout=5)
+            log.warning("Killed %s (pid=%s)", label, proc.pid)
+        except Exception as exc:
+            log.error("Failed to stop %s (pid=%s): %s", label, proc.pid, exc)
+        return
+
+    import signal
+
+    try:
+        os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+    except ProcessLookupError:
+        return
+    except Exception:
+        try:
+            proc.terminate()
+        except Exception:
+            pass
+    try:
+        proc.wait(timeout=5)
+        log.info("Stopped %s (pid=%s) via SIGTERM", label, proc.pid)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    except Exception:
+        pass
+    try:
+        os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+        proc.wait(timeout=5)
+        log.warning("Killed %s (pid=%s) via SIGKILL", label, proc.pid)
+    except ProcessLookupError:
+        return
+    except subprocess.TimeoutExpired:
+        log.error("Failed to stop %s (pid=%s)", label, proc.pid)
+
+
+def kill_processes_by_command_substrings(
+    substrings: list[str],
+    label: str,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Best-effort cleanup of stale child processes matching command-line substrings."""
+    patterns = [s for s in substrings if s]
+    if not patterns:
+        return
+    log = logger or logging.getLogger(__name__)
+    if IS_WINDOWS:
+        patterns_json = json.dumps(patterns, ensure_ascii=False)
+        script = r"""
+$patterns = ConvertFrom-Json @'
+%s
+'@
+$own = %d
+Get-CimInstance Win32_Process | Where-Object {
+  if ($_.ProcessId -eq $own -or -not $_.CommandLine) { return $false }
+  $cmd = $_.CommandLine
+  foreach ($p in $patterns) {
+    if ($p -and $cmd -like ('*' + $p + '*')) { return $true }
+  }
+  return $false
+} | ForEach-Object {
+  try { Stop-Process -Id $_.ProcessId -Force -ErrorAction Stop } catch {}
+}
+""" % (patterns_json, os.getpid())
+        try:
+            subprocess.run(
+                ["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+                timeout=15,
+            )
+            log.info("Requested cleanup of stale %s processes by command substrings", label)
+        except Exception as exc:
+            log.debug("Failed to cleanup stale %s processes: %s", label, exc)
+        return
+
+    try:
+        completed = subprocess.run(
+            ["pgrep", "-f", "|".join(patterns)],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=10,
+        )
+    except Exception as exc:
+        log.debug("pgrep failed for stale %s cleanup: %s", label, exc)
+        return
+    own = {os.getpid(), os.getppid()}
+    for raw_pid in completed.stdout.split():
+        try:
+            pid = int(raw_pid)
+        except ValueError:
+            continue
+        if pid in own:
+            continue
+        try:
+            os.kill(pid, 9)
+            log.info("Killed stale %s process pid=%s", label, pid)
+        except ProcessLookupError:
+            pass
+        except Exception as exc:
+            log.debug("Failed to kill stale %s process pid=%s: %s", label, pid, exc)
+
+
+def executable_name(base: str) -> str:
+    """Return executable name with .exe suffix on Windows."""
+    return f"{base}.exe" if IS_WINDOWS and not base.lower().endswith(".exe") else base

mcp_1c/platform.py

@@ -0,0 +1,187 @@
+"""1С platform discovery helpers.
+
+* detect_version_from_url - fetch the public login page and parse VERSION.
+* find_platform_dir - locate the requested (or latest) platform dir.
+* require_websocket_support - reject unsupported 1C platform versions.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import socket
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlsplit, urlunsplit
+
+from . import os_support
+
+
+def find_free_display(start: int = 99) -> str:
+    """Find the first free Xvfb display starting from `start`."""
+    for n in range(start, 200):
+        path = f"/tmp/.X11-unix/X{n}"
+        if not Path(path).exists():
+            return f":{n}"
+    raise RuntimeError("No free X display found")
+
+
+def find_free_port(start: int = 8765, end: int | None = None) -> int:
+    """Find a free TCP port in the range `start..start+500` (or `start..end`)."""
+    end = end or start + 500
+    for port in range(start, end):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("", port))
+                return port
+            except OSError:
+                continue
+    raise RuntimeError(f"No free port found in range {start}..{end}")
+
+
+_LOCALE_RE = re.compile(r"^[a-z]{2}_[A-Z]{2}$")
+
+
+def normalize_infobase_url(url: str) -> str:
+    """Return a canonical web infobase URL: no language suffix, trailing slash."""
+    value = str(url or "").strip()
+    parts = urlsplit(value)
+    if parts.scheme.lower() not in {"http", "https"}:
+        return value
+    segments = [segment for segment in parts.path.split("/") if segment]
+    if segments and _LOCALE_RE.match(segments[-1]):
+        segments.pop()
+    path = "/" + "/".join(segments) + "/" if segments else "/"
+    return urlunsplit((parts.scheme, parts.netloc, path, "", ""))
+
+
+def detect_version_from_url(url: str) -> Optional[str]:
+    """Fetch a public base_url and extract VERSION from the HTML.
+
+    If the page is behind Basic Auth or simply unavailable, this is not an
+    error; we return None and let the caller pick a default platform version.
+    """
+    try:
+        with urllib.request.urlopen(normalize_infobase_url(url), timeout=10) as resp:
+            html = resp.read().decode("utf-8", errors="ignore")
+            m = re.search(r'var\s+VERSION\s*=\s*"(\d+\.\d+\.\d+\.\d+)"', html)
+            if m:
+                return m.group(1)
+    except (urllib.error.URLError, OSError):
+        pass
+    except Exception:
+        pass
+    return None
+
+
+def _missing_required_tools(path: Path) -> list[str]:
+    return [
+        tool for tool in ("1cv8c", "ibcmd")
+        if not (path / os_support.executable_name(tool)).exists()
+    ]
+
+
+def _is_platform_candidate(path: Path) -> bool:
+    return not _missing_required_tools(path)
+
+
+def _platform_component_score(path: Path) -> tuple[int, int]:
+    """Prefer fuller installations when the same version exists in several roots."""
+    return (
+        1 if (path / os_support.executable_name("ibsrv")).exists() else 0,
+        1 if (path / os_support.executable_name("1cv8")).exists() else 0,
+    )
+
+
+def find_platform_dir(version: Optional[str] = None) -> Path:
+    """Locate the platform directory for a given version.
+
+    If `version` is omitted the maximum available version is selected.
+    Searches standard Linux and Windows installation locations. The
+    ``ONEC_PLATFORM_DIR`` environment variable can point directly to the
+    platform ``bin`` directory and takes precedence.
+    """
+    override = os.getenv("ONEC_PLATFORM_DIR")
+    if override:
+        path = Path(override)
+        missing = _missing_required_tools(path)
+        if not missing:
+            return path
+        raise ValueError(f"ONEC_PLATFORM_DIR does not contain required 1C tools {missing}: {path}")
+
+    candidates: list[Path] = []
+    if os_support.IS_WINDOWS:
+        bases = []
+        for env_name in ("ProgramFiles", "ProgramFiles(x86)"):
+            root = os.getenv(env_name)
+            if root:
+                bases.append(Path(root) / "1cv8")
+        for base in bases:
+            if not base.exists():
+                continue
+            for sub in base.iterdir():
+                bin_dir = sub / "bin"
+                if bin_dir.is_dir() and _is_platform_candidate(bin_dir):
+                    candidates.append(bin_dir)
+                elif sub.is_dir() and _is_platform_candidate(sub):
+                    candidates.append(sub)
+    else:
+        for base in [Path("/opt/1cv8/x86_64"), Path("/opt/1cv8/x86"), Path("/opt/1c/x86_64"), Path("/opt/1c/x86")]:
+            if not base.exists():
+                continue
+            for sub in base.iterdir():
+                if sub.is_dir() and _is_platform_candidate(sub):
+                    candidates.append(sub)
+    if not candidates:
+        raise RuntimeError(
+            "No suitable 1C platform directories found. "
+            "Answer42 requires 1cv8c and ibcmd in the platform bin directory. "
+            "Set ONEC_PLATFORM_DIR to a full platform installation."
+        )
+    if version:
+        matching = [c for c in candidates if platform_version_from_dir(c) == version]
+        if matching:
+            return max(matching, key=_platform_component_score)
+        raise ValueError(f"Версия {version} не найдена среди установленных платформ 1С")
+    # Numeric compare using the first three components to avoid treating the
+    # build number as the most significant part. Windows candidates usually
+    # point to .../<version>/bin, so the version is in the parent directory.
+    return max(
+        candidates,
+        key=lambda p: (_version_tuple(platform_version_from_dir(p)), _platform_component_score(p)),
+    )
+
+
+def platform_version_from_dir(platform_dir: Path) -> str:
+    """Return the 1C version represented by a platform directory.
+
+    Linux installs typically use /opt/1cv8/x86_64/<version>/1cv8c, while
+    Windows installs use C:\\Program Files\\1cv8\\<version>\\bin\\1cv8c.exe.
+    For Windows bin directories, the version is therefore the parent name.
+    """
+    path = Path(platform_dir)
+    if path.name.lower() == "bin" and path.parent.name:
+        return path.parent.name
+    return path.name
+
+
+def _version_tuple(version: str) -> tuple[int, int, int, int]:
+    parts = version.split(".")
+    nums: list[int] = []
+    for p in parts[:4]:
+        try:
+            nums.append(int(p))
+        except ValueError:
+            nums.append(0)
+    while len(nums) < 4:
+        nums.append(0)
+    return (nums[0], nums[1], nums[2], nums[3])
+
+
+def require_websocket_support(version: str) -> None:
+    """Answer42 requires 1С:Предприятие 8.3.27+."""
+    major, minor, patch, _ = _version_tuple(version)
+    if (major, minor, patch) < (8, 3, 27):
+        raise ValueError(f"Версия {version} не поддерживается. Требуется 1С:Предприятие 8.3.27+.")

mcp_1c/protocol.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class BridgeRequest:
+    """Command sent from the Python MCP side to the 1C bridge over WebSocket."""
+
+    id: str
+    method: str
+    params: dict[str, Any]
+
+    def to_json(self) -> dict[str, Any]:
+        return {"type": "request", "id": self.id, "method": self.method, "params": self.params}
+
+
+@dataclass(slots=True)
+class BridgeResponse:
+    """Response returned by the 1C bridge."""
+
+    id: str
+    ok: bool
+    result: Any = None
+    error: str | None = None
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "BridgeResponse":
+        return cls(
+            id=str(data.get("id", "")),
+            ok=bool(data.get("ok", False)),
+            result=data.get("result"),
+            error=data.get("error"),
+        )

mcp_1c/rag/__init__.py

@@ -0,0 +1,5 @@
+"""Local 1C configuration RAG index helpers."""
+
+from .service import RagService
+
+__all__ = ["RagService"]

mcp_1c/rag/detect.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .model import SourceFormat
+
+
+def detect_source_format(path: str | Path) -> SourceFormat:
+    root = Path(path)
+    if not root.exists() or not root.is_dir():
+        return "unknown"
+
+    # EDT-style project: Configuration/Configuration.mdo and object folders with *.mdo.
+    if (root / "Configuration" / "Configuration.mdo").exists():
+        return "edt"
+    if any(root.glob("Catalogs/*/*.mdo")) or any(root.glob("Documents/*/*.mdo")) or any(root.glob("DataProcessors/*/*.mdo")):
+        return "edt"
+
+    # Designer XML dump: Configuration.xml, object XML at root folders, Ext/Form.xml.
+    if (root / "Configuration.xml").exists() or any(root.glob("*/**/Ext/Form.xml")) or any(root.glob("Catalogs/*.xml")):
+        return "designer_xml"
+
+    return "unknown"

mcp_1c/rag/model.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+SourceFormat = Literal["edt", "designer_xml", "unknown"]
+SourceKind = Literal["base", "extension", "configuration", "standalone"]
+
+
+@dataclass(slots=True)
+class SourceInfo:
+    name: str
+    path: Path
+    kind: SourceKind = "standalone"
+    format: SourceFormat = "unknown"
+    repo_url: str | None = None
+    branch: str | None = None
+    commit: str | None = None
+
+
+@dataclass(slots=True)
+class MetadataObject:
+    full_name: str
+    kind: str
+    name: str
+    synonym: str | None = None
+    source_path: str | None = None
+    source_format: SourceFormat = "unknown"
+    is_hierarchical: bool | None = None
+    owner_types: list[str] = field(default_factory=list)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Attribute:
+    object_full_name: str
+    name: str
+    type_name: str | None = None
+    synonym: str | None = None
+    required: bool | None = None
+    source_path: str | None = None
+    role: str = "attribute"
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class TablePart:
+    object_full_name: str
+    name: str
+    synonym: str | None = None
+    source_path: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class TablePartColumn:
+    object_full_name: str
+    table_part: str
+    name: str
+    type_name: str | None = None
+    synonym: str | None = None
+    required: bool | None = None
+    source_path: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class Form:
+    object_full_name: str
+    name: str
+    kind: str | None = None
+    source_path: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class FormElement:
+    object_full_name: str
+    form_name: str
+    name: str
+    element_type: str | None = None
+    title: str | None = None
+    data_path: str | None = None
+    command_name: str | None = None
+    parent_name: str | None = None
+    source_path: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class DataCompositionField:
+    object_full_name: str
+    schema_name: str
+    data_path: str
+    source_field: str | None = None
+    title: str | None = None
+    expression: str | None = None
+    dataset_name: str | None = None
+    field_type: str | None = None
+    source_path: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class ParsedSource:
+    source: SourceInfo
+    objects: list[MetadataObject] = field(default_factory=list)
+    attributes: list[Attribute] = field(default_factory=list)
+    table_parts: list[TablePart] = field(default_factory=list)
+    table_part_columns: list[TablePartColumn] = field(default_factory=list)
+    forms: list[Form] = field(default_factory=list)
+    form_elements: list[FormElement] = field(default_factory=list)
+    data_composition_fields: list[DataCompositionField] = field(default_factory=list)