mcp-edit-math

Instructions

Implementation Reference

• mcp_edit_math.py:269-397 (handler)

  The primary handler function for the 'scan_dependencies' tool. Decorated with @mcp.tool() for registration. Scans code snippets for dependencies in Python (AST), JS/TS/HTML (Tree-sitter), returns formatted analysis with suggested index.

  def scan_dependencies(
      code: str, 
      target_function: str, 
      language: str = "auto", 
      ignore_custom: Union[List[str], str, None] = None
  ) -> str:
      """
      Scans code for dependencies. Supports JS, TS, HTML, Python.
      """
      try:
          if parser_js is None: return "CRITICAL ERROR: Tree-sitter parsers failed to initialize."
          
          # СБРОС СОСТОЯНИЯ ПРИ НОВОМ СКАНИРОВАНИИ
          # Это важно: если ИИ начал сканировать заново, он теряет право на правку
          APPROVAL_STATE[target_function] = "NONE"
          
          normalized_ignore = []
          if isinstance(ignore_custom, list):
              normalized_ignore = ignore_custom
          elif isinstance(ignore_custom, str):
              normalized_ignore = [ignore_custom]
          
          lang_lower = language.lower()
          
          # --- PYTHON ---
          if lang_lower == "python" or lang_lower == "py":
              deps, logs = _extract_python_dependencies(code, target_function, normalized_ignore)
              sorted_deps = sorted(list(deps))
              return f"""
              [ACCESS REVOKED] Python Analysis for '{target_function}':
              --------------------------------
              Found Dependencies: {', '.join(sorted_deps) if sorted_deps else 'None'}
              SUGGESTED INDEX: {target_function + ("_" + "_".join(sorted_deps) if sorted_deps else "")}
              
              DEBUG INFO:
              {chr(10).join(logs[:15])}
              """
  
          # --- HTML ---
          if lang_lower == "html":
              if not parser_html: return "Error: HTML parser not initialized."
              tree = parser_html.parse(bytes(code, "utf8"))
              deps, logs = _extract_html_dependencies(tree)
              sorted_deps = sorted(list(deps))
              return f"""
              [ACCESS REVOKED] HTML Analysis for '{target_function}':
              --------------------------------
              Found Dependencies: {', '.join(sorted_deps) if sorted_deps else 'None'}
              DEBUG INFO:
              {chr(10).join(logs)}
              """
  
          # --- JS / TS ---
          selected_parser = parser_js
          logs_prefix = "JavaScript"
  
          if lang_lower == "auto":
              if "def " in code or "import " in code or "class " in code:
                   try:
                       ast.parse(code)
                       deps, logs = _extract_python_dependencies(code, target_function, normalized_ignore)
                       sorted_deps = sorted(list(deps))
                       return f"""
                       [ACCESS REVOKED] Auto-Detected Python Analysis for '{target_function}':
                       --------------------------------
                       Found Dependencies: {', '.join(sorted_deps) if sorted_deps else 'None'}
                       SUGGESTED INDEX: {target_function + ("_" + "_".join(sorted_deps) if sorted_deps else "")}
                       """
                   except:
                       pass
  
              tree_js = parser_js.parse(bytes(code, "utf8"))
              js_errors = has_syntax_errors(tree_js)
              tree_ts = parser_ts.parse(bytes(code, "utf8"))
              ts_errors = has_syntax_errors(tree_ts)
              
              if js_errors and not ts_errors:
                  return """
                  🛑 AMBIGUITY DETECTED
                  ---------------------
                  The code looks like TypeScript. Please ASK THE USER: "Is this JavaScript or TypeScript?"
                  """
              elif not js_errors:
                  selected_parser = parser_js
                  logs_prefix = "Auto-Detected JS"
              else:
                  selected_parser = parser_ts
                  logs_prefix = "Auto-Detected TS (Fallback)"
                  
          elif lang_lower in ["ts", "typescript", "tsx"]:
              selected_parser = parser_ts
              logs_prefix = "TypeScript"
          elif lang_lower == "python":
              return "Python support via AST module is available in v4.3 if needed."
  
          tree_raw = selected_parser.parse(bytes(code, "utf8"))
          deps, logs = _extract_dependencies_from_tree(tree_raw, target_function, normalized_ignore)
          
          used_wrapper = False
          if not deps:
              logs.append("--- Attempting Auto-Wrapper ---")
              wrapped_code = f"class AutoWrapper {{ {code} }}"
              tree_wrapped = selected_parser.parse(bytes(wrapped_code, "utf8"))
              deps_wrapped, logs_wrapped = _extract_dependencies_from_tree(tree_wrapped, target_function, normalized_ignore)
              if deps_wrapped:
                  deps = deps_wrapped
                  logs.extend(logs_wrapped)
                  used_wrapper = True
  
          sorted_deps = sorted(list(deps))
          index_str = target_function + ("_" + "_".join(sorted_deps) if sorted_deps else "")
          
          debug_output = "\n    ".join(logs[:15])
          
          return f"""
          [ACCESS REVOKED] {logs_prefix} Analysis for '{target_function}':
          --------------------------------
          Found Dependencies: {', '.join(sorted_deps) if sorted_deps else 'None'}
          SUGGESTED INDEX: {index_str}
          
          DEBUG INFO:
          Wrapper Used: {used_wrapper}
          Logs:
          {debug_output}
          ...
          """
      except Exception as e:
          return f"INTERNAL SERVER ERROR during scanning: {str(e)}\nTraceback: {traceback.format_exc()}"

• mcp_edit_math.py:93-139 (helper)

  Helper function to extract dependencies from Python code using AST, ignoring builtins and custom list.

  def _extract_python_dependencies(code: str, target_name: str, ignore_custom: Optional[List[str]] = None) -> Tuple[Set[str], List[str]]:
      dependencies = set()
      logs = []
      try:
          tree = ast.parse(code)
      except SyntaxError as e:
          return set(), [f"Python Syntax Error: {e}"]
  
      target_node = None
      for node in ast.walk(tree):
          if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
              if node.name == target_name:
                  target_node = node
                  break
      
      if target_node:
          logs.append(f"✅ Found Python target: {type(target_node).__name__}")
      else:
          logs.append("❌ Target node NOT found. Scanning entire snippet.")
          target_node = tree
  
      IGNORE_PYTHON = {
          "print", "len", "str", "int", "float", "bool", "list", "dict", "set", "tuple",
          "range", "enumerate", "zip", "map", "filter", "sum", "min", "max", "abs",
          "isinstance", "issubclass", "type", "super", "getattr", "setattr", "hasattr",
          "open", "dir", "id", "input", "repr", "round", "sorted", "reversed",
          "__init__", "__str__", "__repr__", "self"
      }
      if ignore_custom:
          IGNORE_PYTHON.update(ignore_custom)
  
      for node in ast.walk(target_node):
          call_name = None
          if isinstance(node, ast.Call):
              if isinstance(node.func, ast.Name):
                  call_name = node.func.id
              elif isinstance(node.func, ast.Attribute):
                  call_name = node.func.attr
                  if isinstance(node.func.value, ast.Name) and node.func.value.id == 'self':
                      logs.append(f"Found self call: {call_name}")
          
          if call_name:
              if call_name not in IGNORE_PYTHON and call_name != target_name:
                  dependencies.add(call_name)
  
      return dependencies, logs

• mcp_edit_math.py:141-227 (helper)

  Core helper for extracting dependencies from JS/TS Tree-sitter parse trees, scans call expressions and member accesses.

  def _extract_dependencies_from_tree(tree, target_name: str, ignore_custom: Optional[List[str]] = None) -> Tuple[Set[str], List[str]]:
      if not tree: return set(), ["Error: Tree is None"]
      root_node = tree.root_node
      dependencies = set()
      logs = []
  
      def find_target_node(node, name):
          if node.type == 'class_declaration':
              name_node = node.child_by_field_name('name')
              if name_node and name_node.text.decode('utf8') == name: return node
          if node.type == 'function_declaration':
              name_node = node.child_by_field_name('name')
              if name_node and name_node.text.decode('utf8') == name: return node
          elif node.type == 'method_definition':
              name_node = node.child_by_field_name('name')
              if name_node and name_node.text.decode('utf8') == name: return node.child_by_field_name('body')
          elif node.type == 'lexical_declaration':
              for i in range(node.child_count):
                  child = node.child(i)
                  if child.type == 'variable_declarator':
                      name_node = child.child_by_field_name('name')
                      if name_node and name_node.text.decode('utf8') == name: return child.child_by_field_name('value')
          for i in range(node.child_count):
              res = find_target_node(node.child(i), name)
              if res: return res
          return None
  
      target_node = find_target_node(root_node, target_name)
      
      if target_node:
          logs.append(f"✅ Found target node type: {target_node.type}")
      else:
          logs.append("❌ Target node NOT found. Scanning root.")
          target_node = root_node
  
      IGNORE_LIST = {
          "console", "Math", "JSON", "Date", "Object", "Array", "Promise", "Error",
          "parseInt", "parseFloat", "setTimeout", "setInterval", "alert", "confirm",
          "require", "window", "document", "history", "navigator", "location"
      }
      
      IGNORE_METHODS = {
          "log", "error", "warn", "info", "debug",
          "push", "pop", "shift", "unshift", "splice", "slice", "join", "split",
          "map", "filter", "reduce", "forEach", "find", "some", "every",
          "toString", "toFixed", "replace", "replaceAll", "trim",
          "querySelector", "querySelectorAll", "getElementById", "addEventListener",
          "remove", "add", "has", "get", "set", "keys", "values", "entries",
          "now", "abs", "round", "floor", "ceil", "min", "max", "random",
          "then", "catch", "finally", "length", "subscribe", "unsubscribe"
      }
  
      if ignore_custom:
          IGNORE_LIST.update(ignore_custom)
          IGNORE_METHODS.update(ignore_custom)
  
      def find_calls(node):
          if node.type == 'call_expression':
              func_node = node.child_by_field_name('function')
              call_name = None
              
              if func_node.type == 'identifier':
                  call_name = func_node.text.decode('utf8')
              elif func_node.type == 'member_expression':
                  prop_node = func_node.child_by_field_name('property')
                  obj_node = func_node.child_by_field_name('object')
                  if prop_node:
                      method_name = prop_node.text.decode('utf8')
                      obj_name = obj_node.text.decode('utf8') if obj_node else "unknown"
                      if (obj_node.type == 'this') or (obj_name == 'this'):
                          call_name = method_name
                      elif method_name not in IGNORE_METHODS:
                          call_name = method_name
              
              if call_name:
                  if call_name not in IGNORE_LIST and call_name != target_name:
                      dependencies.add(call_name)
                  else:
                      # logs.append(f"Ignored: {call_name}")
                      pass
  
          for i in range(node.child_count):
              find_calls(node.child(i))
  
      find_calls(target_node)
      return dependencies, logs

• mcp_edit_math.py:229-267 (helper)

  Helper to extract dependencies from HTML Tree-sitter tree, focusing on script src and event handlers.

  def _extract_html_dependencies(tree) -> Tuple[Set[str], List[str]]:
      if not tree: return set(), ["Error: HTML Tree is None"]
      root_node = tree.root_node
      dependencies = set()
      logs = []
      
      logs.append("Scanning HTML structure...")
  
      def traverse(node):
          if node.type == 'attribute':
              attr_name = None
              attr_value = None
              
              for i in range(node.child_count):
                  child = node.child(i)
                  if child.type == 'attribute_name':
                      attr_name = child.text.decode('utf8')
                  elif child.type == 'quoted_attribute_value' or child.type == 'attribute_value':
                      attr_value = child.text.decode('utf8').strip('"\'')
  
              if attr_name and attr_value:
                  if attr_name == 'src':
                      parent = node.parent
                      if parent and (parent.type == 'script_start_tag' or parent.type == 'script_element'):
                          dependencies.add(f"FILE: {attr_value}")
                          logs.append(f"Found script: {attr_value}")
                  
                  elif attr_name.startswith('on'):
                      func_name = attr_value.split('(')[0].strip()
                      if func_name:
                          dependencies.add(f"EVENT: {func_name}")
                          logs.append(f"Found event: {attr_name} -> {func_name}")
  
          for i in range(node.child_count):
              traverse(node.child(i))
  
      traverse(root_node)
      return dependencies, logs

• mcp_edit_math.py:275-277 (schema)

  Tool description and implicit schema via type hints in function signature.

  """
  Scans code for dependencies. Supports JS, TS, HTML, Python.
  """