answer42 0.3.3__tar.gz → 0.3.5__tar.gz

{answer42-0.3.3 → answer42-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: answer42
-Version: 0.3.3
+Version: 0.3.5
 Summary: Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API
 Author: Marvin (AI Assistant), 42Clouds, and contributors
 Author-email: "Kosolapov Stanislav (proDOOMman)" <prodoomman@gmail.com>

{answer42-0.3.3 → answer42-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "answer42"
-version = "0.3.3"
+version = "0.3.5"
 description = "Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API"
 readme = "README.md"
 requires-python = ">=3.11"

{answer42-0.3.3 → answer42-0.3.5}/src/mcp_1c/rag/parsers.py

@@ -21,6 +21,8 @@ from .model import (
 )
 
 KIND_DIRS = {
+    "Constants": "Константа",
+    "CommonForms": "ОбщаяФорма",
     "Catalogs": "Справочник",
     "Documents": "Документ",
     "DataProcessors": "Обработка",
@@ -33,6 +35,8 @@ KIND_DIRS = {
     "CalculationRegisters": "РегистрРасчета",
 }
 
+FORM_FILE_NAMES = {"Form.form", "Form.xml"}
+
 
 def _strip_ns(tag: str) -> str:
     return tag.rsplit("}", 1)[-1]
@@ -199,7 +203,10 @@ def parse_edt_source(source: SourceInfo) -> ParsedSource:
             parsed.objects.append(MetadataObject(full, ru_kind, obj_name, synonym, str(mdo), source.format, hierarchical, [o for o in owners if o]))
             if root is not None:
                 _extract_metadata_children(parsed, root, full, mdo)
-            _extract_forms(parsed, mdo.parent, full)
+            if ru_kind == "ОбщаяФорма":
+                _extract_common_form(parsed, mdo.parent, full)
+            else:
+                _extract_forms(parsed, mdo.parent, full)
             _extract_data_composition_schemas(parsed, mdo.parent, full)
             _extract_help_pages(parsed, mdo.parent, full)
     return parsed
@@ -231,12 +238,26 @@ def parse_designer_xml_source(source: SourceInfo) -> ParsedSource:
             if root is not None:
                 _extract_metadata_children(parsed, root, full, xml)
             object_dir = xml.parent if xml.parent != base else base / xml.stem
-            _extract_forms(parsed, object_dir, full)
+            if ru_kind == "ОбщаяФорма":
+                _extract_common_form(parsed, object_dir, full)
+            else:
+                _extract_forms(parsed, object_dir, full)
             _extract_data_composition_schemas(parsed, object_dir, full)
             _extract_help_pages(parsed, object_dir, full)
     return parsed
 
 
+def _extract_common_form(parsed: ParsedSource, object_dir: Path, full: str) -> None:
+    form_xml = _find_form_file(object_dir)
+    parsed.forms.append(Form(full, "Форма", "CommonForm", str(form_xml) if form_xml.exists() else str(object_dir)))
+    if not form_xml.exists():
+        return
+    root = _xml_root(form_xml)
+    if root is not None:
+        _extract_form_elements(parsed, root, full, "Форма", form_xml)
+        _extract_embedded_data_composition_fields(parsed, root, full, "Форма", form_xml)
+
+
 def _extract_metadata_children(parsed: ParsedSource, root: ET.Element, full: str, source_path: Path) -> None:
     # Heuristic parser covering both EDT and designer XML structures.
     # Keep object attributes and table-part columns separate: XML dumps often
@@ -273,9 +294,7 @@ def _extract_forms(parsed: ParsedSource, object_dir: Path, full: str) -> None:
         return
     for form_dir in sorted([p for p in forms_dir.iterdir() if p.is_dir()]):
         form_name = form_dir.name
-        form_xml = form_dir / "Ext" / "Form.xml"
-        if not form_xml.exists():
-            form_xml = form_dir / "Form.xml"
+        form_xml = _find_form_file(form_dir)
         parsed.forms.append(Form(full, form_name, None, str(form_xml) if form_xml.exists() else str(form_dir)))
         if form_xml.exists():
             root = _xml_root(form_xml)
@@ -284,23 +303,34 @@ def _extract_forms(parsed: ParsedSource, object_dir: Path, full: str) -> None:
                 _extract_embedded_data_composition_fields(parsed, root, full, form_name, form_xml)
 
 
+def _find_form_file(form_dir: Path) -> Path:
+    for candidate_dir in (form_dir / "Ext", form_dir):
+        for name in FORM_FILE_NAMES:
+            form_file = candidate_dir / name
+            if form_file.exists():
+                return form_file
+    return form_dir / "Ext" / "Form.xml"
+
+
 def _extract_form_elements(parsed: ParsedSource, root: ET.Element, full: str, form_name: str, source_path: Path) -> None:
     for elem in root.iter():
         tag = _strip_ns(elem.tag)
         low = tag.lower()
-        if low not in {"element", "item", "items", "button", "command", "field", "table", "group"}:
+        if low not in {"element", "item", "items", "button", "command", "field", "table", "group", "extendedtooltip", "contextmenu"}:
             continue
         name = elem.attrib.get("name") or elem.attrib.get("Name") or _first_text(elem, ["name", "Name"])
         if not name:
             continue
+        title = elem.attrib.get("title") or elem.attrib.get("Title") or _first_text(elem, ["title", "Title", "caption", "Caption"])
+        data_path = _form_data_path(elem)
         parsed.form_elements.append(
             FormElement(
                 full,
                 form_name,
                 name,
                 tag,
-                elem.attrib.get("title") or elem.attrib.get("Title") or _first_text(elem, ["title", "Title", "caption", "Caption"]),
-                elem.attrib.get("dataPath") or elem.attrib.get("path") or _first_text(elem, ["dataPath", "path", "DataPath"]),
+                title,
+                data_path,
                 elem.attrib.get("commandName") or _first_text(elem, ["commandName", "CommandName"]),
                 None,
                 str(source_path),
@@ -308,6 +338,20 @@ def _extract_form_elements(parsed: ParsedSource, root: ET.Element, full: str, fo
         )
 
 
+def _form_data_path(elem: ET.Element) -> str | None:
+    direct = elem.attrib.get("dataPath") or elem.attrib.get("path") or _direct_text(elem, ["dataPath", "path", "DataPath"])
+    if direct:
+        return direct
+    for child in list(elem):
+        if _strip_ns(child.tag).lower() == "datapath":
+            segments = [_text(segment) for segment in child.iter() if _strip_ns(segment.tag).lower() in {"segments", "segment"}]
+            values = [value for value in segments if value]
+            if values:
+                return ".".join(values)
+            return _text(child)
+    return None
+
+
 def _extract_embedded_data_composition_fields(parsed: ParsedSource, root: ET.Element, full: str, form_name: str, source_path: Path) -> None:
     dataset_name: str | None = None
     for elem in root.iter():

{answer42-0.3.3 → answer42-0.3.5}/src/mcp_1c/rag/service.py

@@ -5,6 +5,7 @@ import json
 import math
 import os
 import re
+import shutil
 import subprocess
 from pathlib import Path
 from typing import Any
@@ -56,6 +57,45 @@ class RagService:
         with self.store.connect() as con:
             return [dict(r) for r in con.execute("SELECT * FROM sources ORDER BY id")]
 
+    def cleanup_generated_source_files_under(self, root: str | Path, *, remove_files: bool = True) -> dict[str, Any]:
+        """Delete generated dump files under *root* while preserving indexed RAG rows.
+
+        The SQLite RAG index is self-contained after ``build_index`` succeeds, so
+        dumped Designer XML source files can be removed to save disk space.  The
+        source registry rows are intentionally kept: they document which source
+        produced the indexed metadata and keep existing snapshots/index rows
+        intact via foreign keys.
+        """
+        root_path = Path(root).expanduser().resolve()
+        referenced_sources: list[dict[str, Any]] = []
+        skipped: list[dict[str, Any]] = []
+        with self.store.connect() as con:
+            rows = [dict(r) for r in con.execute("SELECT * FROM sources ORDER BY id")]
+            for row in rows:
+                source_path = Path(str(row.get("path") or "")).expanduser()
+                try:
+                    resolved_source = source_path.resolve()
+                    resolved_source.relative_to(root_path)
+                except (OSError, ValueError):
+                    continue
+                branch = str(row.get("branch") or "")
+                commit_hash = str(row.get("commit_hash") or "")
+                if branch or commit_hash:
+                    skipped.append(row | {"reason": "source looks like a VCS checkout"})
+                    continue
+                referenced_sources.append(row)
+
+        removed_paths: list[str] = []
+        if remove_files and root_path.exists() and referenced_sources:
+            shutil.rmtree(root_path)
+            removed_paths.append(str(root_path))
+        return {
+            "root": str(root_path),
+            "referenced_sources_count": len(referenced_sources),
+            "skipped_count": len(skipped),
+            "removed_paths": removed_paths,
+        }
+
     def add_sources_from_directory(self, root: str, prefix: str = "", recursive: bool = True, max_depth: int = 4, watch: bool = False) -> dict[str, Any]:
         discovered = self.discover_sources(root, recursive=recursive, max_depth=max_depth)
         registered: list[dict[str, Any]] = []
@@ -266,6 +306,12 @@ class RagService:
                         continue
                     con.execute("INSERT INTO attributes(object_id,name,type_name,synonym,required,source_path,role,raw_json) VALUES(?,?,?,?,?,?,?,?)", (oid, attr.name, attr.type_name, attr.synonym, attr.required, attr.source_path, attr.role, json_dumps(attr.raw)))
                     counts["attributes"] += 1
+                    text_parts = [attr.object_full_name, attr.role, attr.name, search_text_variants(attr.name, attr.synonym), attr.synonym or "", attr.type_name or ""]
+                    chunk_text = " ".join(part for part in text_parts if part)
+                    cid = _insert_chunk(con, snapshot_id, oid, "attribute", chunk_text, attr.source_path, {"source": src["name"], "role": attr.role})
+                    con.execute("INSERT INTO search_fts(text, object_full_name, kind, source_path, chunk_id) VALUES(?,?,?,?,?)", (chunk_text, attr.object_full_name, "Реквизит", attr.source_path, cid))
+                    _insert_embedding(con, cid, chunk_text)
+                    counts["chunks"] += 1
                 for tp in parsed.table_parts:
                     oid = object_ids.get(tp.object_full_name)
                     if not oid:
@@ -284,12 +330,25 @@ class RagService:
                     cur = con.execute("INSERT INTO forms(object_id,name,kind,source_path,raw_json) VALUES(?,?,?,?,?)", (oid, form.name, form.kind, form.source_path, json_dumps(form.raw)))
                     form_ids[(form.object_full_name, form.name)] = cur.lastrowid
                     counts["forms"] += 1
+                    text_parts = [form.object_full_name, "форма", form.name, search_text_variants(form.name), form.kind or ""]
+                    chunk_text = " ".join(part for part in text_parts if part)
+                    cid = _insert_chunk(con, snapshot_id, oid, "form", chunk_text, form.source_path, {"source": src["name"], "form": form.name})
+                    con.execute("INSERT INTO search_fts(text, object_full_name, kind, source_path, chunk_id) VALUES(?,?,?,?,?)", (chunk_text, form.object_full_name, "Форма", form.source_path, cid))
+                    _insert_embedding(con, cid, chunk_text)
+                    counts["chunks"] += 1
                 for elem in parsed.form_elements:
                     fid = form_ids.get((elem.object_full_name, elem.form_name))
                     if not fid:
                         continue
                     con.execute("INSERT INTO form_elements(form_id,name,element_type,title,data_path,command_name,parent_name,source_path,raw_json) VALUES(?,?,?,?,?,?,?,?,?)", (fid, elem.name, elem.element_type, elem.title, elem.data_path, elem.command_name, elem.parent_name, elem.source_path, json_dumps(elem.raw)))
                     counts["form_elements"] += 1
+                    oid = object_ids.get(elem.object_full_name)
+                    text_parts = [elem.object_full_name, "элемент формы", elem.form_name, elem.name, search_text_variants(elem.name, elem.title, elem.data_path), elem.title or "", elem.data_path or "", elem.command_name or "", elem.element_type or ""]
+                    chunk_text = " ".join(part for part in text_parts if part)
+                    cid = _insert_chunk(con, snapshot_id, oid, "form_element", chunk_text, elem.source_path, {"source": src["name"], "form": elem.form_name, "element": elem.name})
+                    con.execute("INSERT INTO search_fts(text, object_full_name, kind, source_path, chunk_id) VALUES(?,?,?,?,?)", (chunk_text, elem.object_full_name, "ЭлементФормы", elem.source_path, cid))
+                    _insert_embedding(con, cid, chunk_text)
+                    counts["chunks"] += 1
                 for dcs_field in parsed.data_composition_fields:
                     oid = object_ids.get(dcs_field.object_full_name)
                     if not oid:

{answer42-0.3.3 → answer42-0.3.5}/src/mcp_1c/server.py

@@ -63,6 +63,62 @@ _SHARED_FILE_SERVERS_FILE = os_support.runtime_path("ONEC_MCP_SHARED_FILE_SERVER
 _SHARED_FILE_SERVERS_LOCK = os_support.runtime_path("ONEC_MCP_SHARED_FILE_SERVERS_LOCK", "shared-file-servers.lock")
 _METADATA_OBJECTS_CACHE: dict[str, dict[str, Any]] = {}
 
+TOOL_PROFILE_GROUPS: dict[str, set[str]] = {
+    "sessions": {
+        "sessions_list", "session_status", "start_session", "stop_session", "export_eventlog",
+        "credentials_check", "credentials_save", "credentials_remove", "credentials_list", "credentials_titles",
+    },
+    "windows": {"active_window", "windows_list", "activate_window", "goto_start_page", "goto_previous_window", "goto_next_window"},
+    "forms": {
+        "wait_object", "wait_form", "wait_window", "user_messages", "close_user_messages_panel", "current_error_info",
+        "set_file_dialog_result", "clear_file_dialog_result", "field_info", "field_value_text", "field_tooltip",
+        "field_dropdown_items", "form_next_element", "form_previous_element", "form_state", "form_default_button",
+        "wait_form_closed", "object_command_panel", "object_context_menu", "window_command_interface",
+        "command_interface_sections", "command_interface_commands", "command_interface_search", "group_expand", "group_collapse",
+        "group_current_page", "group_activate_page", "group_state", "decoration_links", "decoration_click_link", "decoration_click",
+        "ui_tree", "command_bar", "click_button", "find_object", "search_objects", "get_object", "activate_object",
+        "open_navigation_link", "current_element", "field_dropdown_state", "field_dropdown_close", "toggle_field",
+        "set_field_value", "activate_field", "choose_field_from_list", "choose_field_first_row", "choose_current_row",
+        "set_form_fields", "create_new_item", "save_form", "close_form", "form_open_settings",
+    },
+    "tables": {
+        "table_current_row", "table_selected_rows", "table_cell_text", "table_rows", "table_find_row", "table_goto_row",
+        "table_move_row", "table_add_row", "table_set_field", "table_set_row_values", "table_choose_field_from_list",
+        "table_edit_info", "table_select_all", "table_clear_selection", "table_delete_row", "table_copy_row",
+        "table_toggle_delete_mark", "table_begin_edit", "table_end_edit", "table_editing_state",
+    },
+    "tabular": {"tabular_documents", "tabular_document_text", "tabular_document_save", "tabular_document_state_display"},
+    "dynamic": {
+        "dynamic_list_metadata_available_fields", "dynamic_list_settings_available_fields", "dynamic_list_set_settings",
+        "dynamic_list_current_settings", "dynamic_list_sort_by_column", "dynamic_list_output", "dynamic_list_open_settings",
+        "dynamic_list_find", "dynamic_list_filter_by_current_value", "dynamic_list_clear_settings",
+    },
+    "rag": {
+        "rag_source_add", "rag_sources_add_from_directory", "rag_source_roots_list", "rag_available_configurations",
+        "rag_session_autoconfigure", "rag_sources_list", "rag_snapshot_create", "rag_snapshots_list", "rag_index_build",
+        "rag_lookup_object", "rag_query", "metadata_objects_from_catalog", "metadata_objects_catalog_cache_clear",
+        "configuration_name_version_from_subsystems", "installed_extensions_from_catalog",
+    },
+    "recording": {"recording_start", "recording_capture", "recording_stop", "screenshot"},
+}
+TOOL_PROFILE_CORE: set[str] = TOOL_PROFILE_GROUPS["sessions"] | {
+    "active_window", "windows_list", "activate_window", "goto_start_page", "goto_previous_window", "goto_next_window",
+    "wait_object", "wait_form", "wait_window", "user_messages", "close_user_messages_panel", "current_error_info",
+    "field_info", "field_value_text", "field_dropdown_items", "field_dropdown_state", "field_dropdown_close",
+    "toggle_field", "set_field_value", "activate_field", "choose_field_from_list", "choose_field_first_row", "choose_current_row",
+    "form_state", "form_default_button", "wait_form_closed", "click_button", "find_object", "search_objects", "get_object",
+    "activate_object", "open_navigation_link", "current_element", "table_current_row", "table_selected_rows", "table_cell_text",
+    "table_rows", "table_find_row", "table_goto_row", "table_move_row", "table_add_row", "table_set_field", "table_set_row_values",
+    "table_choose_field_from_list", "table_edit_info", "table_begin_edit", "table_end_edit", "table_editing_state",
+    "tabular_documents", "tabular_document_text", "tabular_document_save", "screenshot",
+}
+TOOL_PROFILE_ALIASES: dict[str, set[str]] = {
+    "core": TOOL_PROFILE_CORE,
+    "ui": TOOL_PROFILE_GROUPS["sessions"] | TOOL_PROFILE_GROUPS["windows"] | TOOL_PROFILE_GROUPS["forms"] | TOOL_PROFILE_GROUPS["tables"] | TOOL_PROFILE_GROUPS["tabular"] | TOOL_PROFILE_GROUPS["recording"],
+    "all": set(),
+    "full": set(),
+}
+
 
 @contextmanager
 def _port_allocation_lock():
@@ -1880,6 +1936,7 @@ async def rag_session_autoconfigure(
     cfe_files: Annotated[str, "Optional JSON/comma list of .cfe files to load into temporary file IBs and dump as extensions"] = "",
     dump_root: Annotated[str, "Optional persistent directory for generated RAG source dumps"] = "",
     cleanup_tmp_infobases: Annotated[bool, "Remove temporary file infobases created while loading CF/CFE files"] = True,
+    cleanup_generated_sources: Annotated[bool, "Remove generated XML source dumps after a successful RAG index build"] = True,
     *,
     session_id: Annotated[str, "Session id"] = DEFAULT_SESSION,
 ) -> dict[str, Any]:
@@ -1898,8 +1955,10 @@ async def rag_session_autoconfigure(
     (for example multitenant/separated-data infobases), pass `dump_username` and
     `dump_password`; otherwise the current session credentials are reused.
     Temporary infobases created from CF/CFE files are deleted after dumping by
-    default; generated XML source directories are kept under `dump_root` (or the
-    Answer42 temp rag-dumps directory) because the RAG index references them.
+    default.  Generated XML source directories are removed after a successful
+    index build by default, because the SQLite RAG index is self-contained; pass
+    `cleanup_generated_sources=false` when the dumped XML source tree should be
+    kept under `dump_root` for inspection or reuse.
     """
     params = {
         "snapshot_name": snapshot_name,
@@ -1916,6 +1975,7 @@ async def rag_session_autoconfigure(
         "cfe_files": cfe_files,
         "dump_root": dump_root,
         "cleanup_tmp_infobases": cleanup_tmp_infobases,
+        "cleanup_generated_sources": cleanup_generated_sources,
     }
     disabled = _rag_require_enabled(session_id, "rag_session_autoconfigure", params)
     if disabled is not None:
@@ -2145,6 +2205,9 @@ async def rag_session_autoconfigure(
     _persist_sessions()
 
     index_result = _RAG.build_index(snapshot=sess.rag_snapshot) if build_index else None
+    cleanup_generated_sources_result = None
+    if cleanup_generated_sources and index_result is not None and dump_base_dir is not None:
+        cleanup_generated_sources_result = _RAG.cleanup_generated_source_files_under(dump_base_dir)
     result = {
         "snapshot": sess.rag_snapshot,
         "snapshot_result": snapshot,
@@ -2156,7 +2219,9 @@ async def rag_session_autoconfigure(
         "extension_matches": extension_matches,
         "dumps": dumps,
         "generated_sources": generated_sources,
+        "generated_sources_count": len(generated_sources),
         "dump_root": str(dump_base_dir) if dump_base_dir else "",
+        "cleanup_generated_sources": cleanup_generated_sources_result,
         "available_sources_count": len(sources),
         "session_snapshot": sess.rag_snapshot,
     }
@@ -5660,6 +5725,40 @@ def _register_dev_tools(enabled: bool) -> None:
         )
 
 
+def _tool_names_for_profile(profile: str) -> set[str] | None:
+    parts = [part.strip().lower() for part in re.split(r"[,;\s]+", profile or "") if part.strip()]
+    if not parts or any(part in {"all", "full"} for part in parts):
+        return None
+    selected: set[str] = set()
+    unknown: list[str] = []
+    for part in parts:
+        names = TOOL_PROFILE_ALIASES.get(part) or TOOL_PROFILE_GROUPS.get(part)
+        if names is None:
+            unknown.append(part)
+            continue
+        selected.update(names)
+    if unknown:
+        known = sorted({*TOOL_PROFILE_GROUPS, *TOOL_PROFILE_ALIASES})
+        raise ValueError(f"unknown tool profile(s): {', '.join(unknown)}; known profiles: {', '.join(known)}")
+    return selected
+
+
+def _apply_tool_profile(profile: str) -> dict[str, Any]:
+    allowed = _tool_names_for_profile(profile)
+    if allowed is None:
+        return {"profile": profile or "full", "mode": "full", "removed": []}
+    existing = set(getattr(mcp, "_tool_manager")._tools.keys())
+    removed: list[str] = []
+    for name in sorted(existing - allowed):
+        try:
+            mcp.remove_tool(name)
+            removed.append(name)
+        except Exception:
+            pass
+    remaining = sorted(set(getattr(mcp, "_tool_manager")._tools.keys()))
+    return {"profile": profile, "mode": "filtered", "remaining_count": len(remaining), "removed_count": len(removed), "removed": removed}
+
+
 def main(argv: list[str] | None = None) -> None:
     global _RAG_ENABLED, _CREDENTIAL_STORE_ENABLED, _DEV_TOOLS_ENABLED
 
@@ -5730,6 +5829,11 @@ def main(argv: list[str] | None = None) -> None:
         default=os.getenv("ONEC_MCP_SESSION_SCOPE_ID") or os.getenv("ONEC_MCP_SESSION_SCOPE") or "",
         help="enable scoped lock/reconnect mode for the given session scope id; without this flag Answer42 uses legacy no-lock global state",
     )
+    parser.add_argument(
+        "--tool-profile",
+        default=os.getenv("ONEC_MCP_TOOL_PROFILE", "full"),
+        help="comma-separated tool profile groups: core, ui, sessions, windows, forms, tables, tabular, dynamic, rag, recording, full, all",
+    )
     args = parser.parse_args(argv)
 
     _RAG_ENABLED = not args.disable_rag
@@ -5741,6 +5845,8 @@ def main(argv: list[str] | None = None) -> None:
         _register_startup_rag_source_dirs(args.rag_source_dir or [], args.rag_source_prefix, not args.rag_source_no_recursive, args.rag_source_max_depth)
     else:
         logging.info("Built-in Answer42 RAG is disabled")
+    profile_result = _apply_tool_profile(args.tool_profile)
+    logging.info("Tool profile: %s (mode=%s, remaining=%d, removed=%d)", profile_result["profile"], profile_result["mode"], profile_result.get("remaining_count", 0), profile_result.get("removed_count", 0))
     _start_autoreload_watcher(args.dev, args.dev_restart_timeout)
     if args.session_scope:
         _configure_session_scope(args.session_scope)