tree-sitter-analyzer 1.7.2__py3-none-any.whl → 1.7.3__py3-none-any.whl

tree_sitter_analyzer/languages/python_plugin.py

@@ -126,7 +126,8 @@ class PythonElementExtractor(ElementExtractor):
 
             language = tree.language if hasattr(tree, "language") else None
             if language:
-                query = language.query(class_query)
+                import tree_sitter
+                query = tree_sitter.Query(language, class_query)
                 captures = query.captures(tree.root_node)
 
                 if isinstance(captures, dict):
@@ -729,26 +730,83 @@ class PythonElementExtractor(ElementExtractor):
             language = tree.language if hasattr(tree, "language") else None
             if language:
                 for query_string in import_queries:
-                    query = language.query(query_string)
-                    captures = query.captures(tree.root_node)
-
-                    if isinstance(captures, dict):
-                        # Process different types of imports
-                        for key, nodes in captures.items():
-                            if key.endswith("statement"):
-                                import_type = key.split(".")[0]
-                                for node in nodes:
-                                    imp = self._extract_import_info(
-                                        node, source_code, import_type
-                                    )
-                                    if imp:
-                                        imports.append(imp)
+                    try:
+                        import tree_sitter
+                        query = tree_sitter.Query(language, query_string)
+                        captures = query.captures(tree.root_node)
+
+                        if isinstance(captures, dict):
+                            # Process different types of imports
+                            for key, nodes in captures.items():
+                                if key.endswith("statement"):
+                                    import_type = key.split(".")[0]
+                                    for node in nodes:
+                                        imp = self._extract_import_info(
+                                            node, source_code, import_type
+                                        )
+                                        if imp:
+                                            imports.append(imp)
+                    except Exception as query_error:
+                        # Fallback to manual extraction for tree-sitter 0.25.x compatibility
+                        log_warning(f"Query execution failed, using manual extraction: {query_error}")
+                        imports.extend(self._extract_imports_manual(tree.root_node, source_code))
+                        break
 
         except Exception as e:
             log_warning(f"Could not extract Python imports: {e}")
+            # Final fallback
+            imports.extend(self._extract_imports_manual(tree.root_node, source_code))
 
         return imports
 
+    def _extract_imports_manual(self, root_node: "tree_sitter.Node", source_code: str) -> list[Import]:
+        """Manual import extraction for tree-sitter 0.25.x compatibility"""
+        imports = []
+        
+        def walk_tree(node):
+            if node.type in ["import_statement", "import_from_statement"]:
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    raw_text = source_code[node.start_byte:node.end_byte] if hasattr(node, 'start_byte') else ""
+                    
+                    # Extract module name from the import statement
+                    module_name = ""
+                    imported_names = []
+                    
+                    if node.type == "import_statement":
+                        # Simple import: import os, sys
+                        for child in node.children:
+                            if child.type == "dotted_name":
+                                module_name = source_code[child.start_byte:child.end_byte] if hasattr(child, 'start_byte') else ""
+                                imported_names.append(module_name)
+                    elif node.type == "import_from_statement":
+                        # From import: from os import path
+                        for child in node.children:
+                            if child.type == "dotted_name" and not module_name:
+                                module_name = source_code[child.start_byte:child.end_byte] if hasattr(child, 'start_byte') else ""
+                    
+                    if module_name or imported_names:
+                        import_obj = Import(
+                            name=module_name or imported_names[0] if imported_names else "unknown",
+                            start_line=start_line,
+                            end_line=end_line,
+                            raw_text=raw_text,
+                            module_name=module_name,
+                            imported_names=imported_names,
+                            element_type="import"
+                        )
+                        imports.append(import_obj)
+                except Exception as e:
+                    log_warning(f"Failed to extract import manually: {e}")
+            
+            # Recursively process children
+            for child in node.children:
+                walk_tree(child)
+        
+        walk_tree(root_node)
+        return imports
+
     def _extract_detailed_function_info(
         self, node: "tree_sitter.Node", source_code: str, is_async: bool = False
     ) -> Function | None:
@@ -1272,7 +1330,8 @@ class PythonPlugin(LanguagePlugin):
             else:
                 return {"error": f"Unknown query: {query_name}"}
 
-            query = language.query(query_string)
+            import tree_sitter
+            query = tree_sitter.Query(language, query_string)
             captures = query.captures(tree.root_node)
             return {"captures": captures, "query": query_string}
 

tree_sitter_analyzer/queries/markdown.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+Markdown Query Definitions
+
+Tree-sitter queries for extracting Markdown elements including headers,
+links, code blocks, lists, and other structural elements.
+"""
+
+from typing import Dict, List
+
+# Markdown element extraction queries
+MARKDOWN_QUERIES: Dict[str, str] = {
+    # Headers (H1-H6)
+    "headers": """
+    (atx_heading
+        (atx_h1_marker) @h1.marker
+        heading_content: (inline) @h1.content) @h1.heading
+    
+    (atx_heading
+        (atx_h2_marker) @h2.marker
+        heading_content: (inline) @h2.content) @h2.heading
+    
+    (atx_heading
+        (atx_h3_marker) @h3.marker
+        heading_content: (inline) @h3.content) @h3.heading
+    
+    (atx_heading
+        (atx_h4_marker) @h4.marker
+        heading_content: (inline) @h4.content) @h4.heading
+    
+    (atx_heading
+        (atx_h5_marker) @h5.marker
+        heading_content: (inline) @h5.content) @h5.heading
+    
+    (atx_heading
+        (atx_h6_marker) @h6.marker
+        heading_content: (inline) @h6.content) @h6.heading
+    
+    (setext_heading
+        heading_content: (paragraph) @setext.content
+        (setext_h1_underline) @setext.h1) @setext.h1.heading
+    
+    (setext_heading
+        heading_content: (paragraph) @setext.content
+        (setext_h2_underline) @setext.h2) @setext.h2.heading
+    """,
+    
+    # Code blocks
+    "code_blocks": """
+    (fenced_code_block
+        (fenced_code_block_delimiter) @code.start
+        (info_string)? @code.language
+        (code_fence_content) @code.content
+        (fenced_code_block_delimiter) @code.end) @code.block
+    
+    (indented_code_block
+        (code_fence_content) @indented_code.content) @indented_code.block
+    """,
+    
+    # Inline code
+    "inline_code": """
+    (code_span
+        (code_span_delimiter) @inline_code.start
+        (code_span_content) @inline_code.content
+        (code_span_delimiter) @inline_code.end) @inline_code.span
+    """,
+    
+    # Links
+    "links": """
+    (link
+        (link_text) @link.text
+        (link_destination) @link.url
+        (link_title)? @link.title) @link.element
+    
+    (autolink
+        (uri_autolink) @autolink.uri) @autolink.element
+    
+    (autolink
+        (email_autolink) @autolink.email) @autolink.element
+    
+    (reference_link
+        (link_text) @ref_link.text
+        (link_label) @ref_link.label) @ref_link.element
+    
+    (link_reference_definition
+        (link_label) @link_def.label
+        (link_destination) @link_def.url
+        (link_title)? @link_def.title) @link_def.element
+    """,
+    
+    # Images
+    "images": """
+    (image
+        (image_description) @image.alt
+        (link_destination) @image.url
+        (link_title)? @image.title) @image.element
+    
+    (reference_image
+        (image_description) @ref_image.alt
+        (link_label) @ref_image.label) @ref_image.element
+    """,
+    
+    # Lists
+    "lists": """
+    (list
+        (list_item
+            (list_marker) @list_item.marker
+            (paragraph)? @list_item.content) @list_item.element) @list.element
+    
+    (tight_list
+        (list_item
+            (list_marker) @tight_list_item.marker
+            (paragraph)? @tight_list_item.content) @tight_list_item.element) @tight_list.element
+    """,
+    
+    # Emphasis and strong
+    "emphasis": """
+    (emphasis
+        (emphasis_delimiter) @emphasis.start
+        (inline) @emphasis.content
+        (emphasis_delimiter) @emphasis.end) @emphasis.element
+    
+    (strong_emphasis
+        (strong_emphasis_delimiter) @strong.start
+        (inline) @strong.content
+        (strong_emphasis_delimiter) @strong.end) @strong.element
+    """,
+    
+    # Blockquotes
+    "blockquotes": """
+    (block_quote
+        (block_quote_marker) @blockquote.marker
+        (paragraph) @blockquote.content) @blockquote.element
+    """,
+    
+    # Tables
+    "tables": """
+    (pipe_table
+        (pipe_table_header
+            (pipe_table_cell) @table_header.cell) @table.header
+        (pipe_table_delimiter_row) @table.delimiter
+        (pipe_table_row
+            (pipe_table_cell) @table_row.cell) @table.row) @table.element
+    """,
+    
+    # Horizontal rules
+    "horizontal_rules": """
+    (thematic_break) @hr.element
+    """,
+    
+    # HTML blocks
+    "html_blocks": """
+    (html_block) @html.block
+    """,
+    
+    # Inline HTML
+    "inline_html": """
+    (html_tag) @html.inline
+    """,
+    
+    # Strikethrough (if supported)
+    "strikethrough": """
+    (strikethrough
+        (strikethrough_delimiter) @strike.start
+        (inline) @strike.content
+        (strikethrough_delimiter) @strike.end) @strike.element
+    """,
+    
+    # Task lists (if supported)
+    "task_lists": """
+    (list_item
+        (list_marker) @task.marker
+        (task_list_marker_checked) @task.checked) @task.checked_item
+    
+    (list_item
+        (list_marker) @task.marker
+        (task_list_marker_unchecked) @task.unchecked) @task.unchecked_item
+    """,
+    
+    # Footnotes
+    "footnotes": """
+    (footnote_reference
+        (footnote_label) @footnote.ref_label) @footnote.reference
+    
+    (footnote_definition
+        (footnote_label) @footnote.def_label
+        (paragraph) @footnote.content) @footnote.definition
+    """,
+    
+    # All text content
+    "text_content": """
+    (paragraph
+        (inline) @text.content) @text.paragraph
+    
+    (inline) @text.inline
+    """,
+    
+    # Document structure
+    "document": """
+    (document) @document.root
+    """,
+    
+    # All elements (comprehensive)
+    "all_elements": """
+    (atx_heading) @element.heading
+    (setext_heading) @element.heading
+    (fenced_code_block) @element.code_block
+    (indented_code_block) @element.code_block
+    (code_span) @element.inline_code
+    (link) @element.link
+    (autolink) @element.autolink
+    (reference_link) @element.ref_link
+    (image) @element.image
+    (reference_image) @element.ref_image
+    (list) @element.list
+    (tight_list) @element.list
+    (emphasis) @element.emphasis
+    (strong_emphasis) @element.strong
+    (strikethrough) @element.strikethrough
+    (block_quote) @element.blockquote
+    (pipe_table) @element.table
+    (thematic_break) @element.hr
+    (html_block) @element.html_block
+    (html_tag) @element.html_inline
+    (footnote_reference) @element.footnote_ref
+    (footnote_definition) @element.footnote_def
+    (paragraph) @element.paragraph
+    """,
+}
+
+# Query aliases for convenience
+QUERY_ALIASES: Dict[str, str] = {
+    "heading": "headers",
+    "h1": "headers",
+    "h2": "headers", 
+    "h3": "headers",
+    "h4": "headers",
+    "h5": "headers",
+    "h6": "headers",
+    "code": "code_blocks",
+    "fenced_code": "code_blocks",
+    "code_span": "inline_code",
+    "link": "links",
+    "url": "links",
+    "image": "images",
+    "img": "images",
+    "list": "lists",
+    "ul": "lists",
+    "ol": "lists",
+    "em": "emphasis",
+    "strong": "emphasis",
+    "bold": "emphasis",
+    "italic": "emphasis",
+    "quote": "blockquotes",
+    "blockquote": "blockquotes",
+    "table": "tables",
+    "hr": "horizontal_rules",
+    "html": "html_blocks",
+    "strike": "strikethrough",
+    "task": "task_lists",
+    "todo": "task_lists",
+    "footnote": "footnotes",
+    "note": "footnotes",
+    "text": "text_content",
+    "paragraph": "text_content",
+    "all": "all_elements",
+    "everything": "all_elements",
+}
+
+def get_query(query_name: str) -> str:
+    """
+    Get a query by name, supporting aliases
+    
+    Args:
+        query_name: Name of the query or alias
+        
+    Returns:
+        Query string
+        
+    Raises:
+        KeyError: If query name is not found
+    """
+    # Check direct queries first
+    if query_name in MARKDOWN_QUERIES:
+        return MARKDOWN_QUERIES[query_name]
+    
+    # Check aliases
+    if query_name in QUERY_ALIASES:
+        actual_query = QUERY_ALIASES[query_name]
+        return MARKDOWN_QUERIES[actual_query]
+    
+    raise KeyError(f"Unknown query: {query_name}")
+
+def get_available_queries() -> List[str]:
+    """
+    Get list of all available query names including aliases
+    
+    Returns:
+        List of query names
+    """
+    queries = list(MARKDOWN_QUERIES.keys())
+    aliases = list(QUERY_ALIASES.keys())
+    return sorted(queries + aliases)
+
+def get_query_info(query_name: str) -> Dict[str, str]:
+    """
+    Get information about a query
+    
+    Args:
+        query_name: Name of the query
+        
+    Returns:
+        Dictionary with query information
+    """
+    try:
+        query_string = get_query(query_name)
+        is_alias = query_name in QUERY_ALIASES
+        actual_name = QUERY_ALIASES.get(query_name, query_name) if is_alias else query_name
+        
+        return {
+            "name": query_name,
+            "actual_name": actual_name,
+            "is_alias": is_alias,
+            "query": query_string,
+            "description": _get_query_description(actual_name)
+        }
+    except KeyError:
+        return {"error": f"Query '{query_name}' not found"}
+
+def _get_query_description(query_name: str) -> str:
+    """Get description for a query"""
+    descriptions = {
+        "headers": "Extract all heading elements (H1-H6, both ATX and Setext styles)",
+        "code_blocks": "Extract fenced and indented code blocks",
+        "inline_code": "Extract inline code spans",
+        "links": "Extract all types of links (inline, reference, autolinks)",
+        "images": "Extract image elements (inline and reference)",
+        "lists": "Extract ordered and unordered lists",
+        "emphasis": "Extract emphasis and strong emphasis elements",
+        "blockquotes": "Extract blockquote elements",
+        "tables": "Extract pipe table elements",
+        "horizontal_rules": "Extract horizontal rule elements",
+        "html_blocks": "Extract HTML block elements",
+        "inline_html": "Extract inline HTML elements",
+        "strikethrough": "Extract strikethrough elements",
+        "task_lists": "Extract task list items (checkboxes)",
+        "footnotes": "Extract footnote references and definitions",
+        "text_content": "Extract all text content",
+        "document": "Extract document root",
+        "all_elements": "Extract all Markdown elements"
+    }
+    return descriptions.get(query_name, "No description available")
+
+def get_all_queries() -> dict[str, str]:
+    """
+    Get all queries for the query loader
+    
+    Returns:
+        Dictionary mapping query names to query strings
+    """
+    # Combine direct queries and aliases
+    all_queries = MARKDOWN_QUERIES.copy()
+    
+    # Add aliases that point to actual queries
+    for alias, target in QUERY_ALIASES.items():
+        if target in MARKDOWN_QUERIES:
+            all_queries[alias] = MARKDOWN_QUERIES[target]
+    
+    return all_queries
+
+# Export main functions and constants
+__all__ = [
+    "MARKDOWN_QUERIES",
+    "QUERY_ALIASES",
+    "get_query",
+    "get_available_queries",
+    "get_query_info",
+    "get_all_queries"
+]

tree_sitter_analyzer/query_loader.py

@@ -156,6 +156,7 @@ class QueryLoader:
             "cpp",
             "rust",
             "go",
+            "markdown",
         ]
 
         for language in known_languages:

{tree_sitter_analyzer-1.7.2.dist-info → tree_sitter_analyzer-1.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 1.7.2
+Version: 1.7.3
 Summary: Extensible multi-language code analyzer framework using Tree-sitter with dynamic plugin architecture
 Project-URL: Homepage, https://github.com/aimasteracc/tree-sitter-analyzer
 Project-URL: Documentation, https://github.com/aimasteracc/tree-sitter-analyzer#readme
@@ -37,8 +37,9 @@ Requires-Dist: mcp>=1.12.3
 Requires-Dist: tree-sitter-cpp<0.25.0,>=0.23.4
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1
+Requires-Dist: tree-sitter-markdown>=0.3.1
 Requires-Dist: tree-sitter-python<0.25.0,>=0.23.6
-Requires-Dist: tree-sitter==0.24.0
+Requires-Dist: tree-sitter>=0.25.0
 Provides-Extra: all
 Requires-Dist: anyio>=4.0.0; extra == 'all'
 Requires-Dist: black>=24.0.0; extra == 'all'
@@ -61,6 +62,7 @@ Requires-Dist: tree-sitter-cpp<0.25.0,>=0.23.4; extra == 'all'
 Requires-Dist: tree-sitter-go<0.25.0,>=0.20.0; extra == 'all'
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5; extra == 'all'
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1; extra == 'all'
+Requires-Dist: tree-sitter-markdown>=0.3.1; extra == 'all'
 Requires-Dist: tree-sitter-python<0.25.0,>=0.23.0; extra == 'all'
 Requires-Dist: tree-sitter-rust<0.25.0,>=0.20.0; extra == 'all'
 Requires-Dist: tree-sitter-typescript<0.25.0,>=0.20.0; extra == 'all'
@@ -71,6 +73,7 @@ Requires-Dist: tree-sitter-cpp<0.25.0,>=0.23.4; extra == 'all-languages'
 Requires-Dist: tree-sitter-go<0.25.0,>=0.20.0; extra == 'all-languages'
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5; extra == 'all-languages'
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1; extra == 'all-languages'
+Requires-Dist: tree-sitter-markdown>=0.3.1; extra == 'all-languages'
 Requires-Dist: tree-sitter-python<0.25.0,>=0.23.0; extra == 'all-languages'
 Requires-Dist: tree-sitter-rust<0.25.0,>=0.20.0; extra == 'all-languages'
 Requires-Dist: tree-sitter-typescript<0.25.0,>=0.20.0; extra == 'all-languages'
@@ -113,6 +116,7 @@ Requires-Dist: tree-sitter-cpp<0.25.0,>=0.23.4; extra == 'full'
 Requires-Dist: tree-sitter-go<0.25.0,>=0.20.0; extra == 'full'
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5; extra == 'full'
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1; extra == 'full'
+Requires-Dist: tree-sitter-markdown>=0.3.1; extra == 'full'
 Requires-Dist: tree-sitter-python<0.25.0,>=0.23.0; extra == 'full'
 Requires-Dist: tree-sitter-rust<0.25.0,>=0.20.0; extra == 'full'
 Requires-Dist: tree-sitter-typescript<0.25.0,>=0.20.0; extra == 'full'
@@ -123,6 +127,8 @@ Provides-Extra: java
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5; extra == 'java'
 Provides-Extra: javascript
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1; extra == 'javascript'
+Provides-Extra: markdown
+Requires-Dist: tree-sitter-markdown>=0.3.1; extra == 'markdown'
 Provides-Extra: mcp
 Requires-Dist: anyio>=4.0.0; extra == 'mcp'
 Requires-Dist: httpx<1.0.0,>=0.27.0; extra == 'mcp'
@@ -165,11 +171,11 @@ Description-Content-Type: text/markdown
 
 [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-2675%20passed-brightgreen.svg)](#quality-assurance)
-[![Coverage](https://img.shields.io/badge/coverage-78.85%25-green.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-2831%20passed-brightgreen.svg)](#quality-assurance)
+[![Coverage](https://img.shields.io/badge/coverage-79.19%25-green.svg)](#quality-assurance)
 [![Quality](https://img.shields.io/badge/quality-enterprise%20grade-blue.svg)](#quality-assurance)
 [![PyPI](https://img.shields.io/pypi/v/tree-sitter-analyzer.svg)](https://pypi.org/project/tree-sitter-analyzer/)
-[![Version](https://img.shields.io/badge/version-1.7.2-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
+[![Version](https://img.shields.io/badge/version-1.7.3-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/aimasteracc/tree-sitter-analyzer.svg?style=social)](https://github.com/aimasteracc/tree-sitter-analyzer)
 
 ## 🚀 Enterprise-Grade Code Analysis Tool for the AI Era
@@ -213,13 +219,14 @@ Tree-sitter Analyzer is an enterprise-grade code analysis tool designed for the
 | **Python** | Complete Support | Type annotations, decorators, modern Python features |
 | **JavaScript** | Complete Support | ES6+, React/Vue/Angular, JSX |
 | **TypeScript** | Complete Support | Interfaces, types, decorators, TSX/JSX, framework detection |
+| **Markdown** | 🆕 Complete Support | Headers, code blocks, links, images, tables, task lists, blockquotes |
 | **C/C++** | Basic Support | Basic syntax parsing |
 | **Rust** | Basic Support | Basic syntax parsing |
 | **Go** | Basic Support | Basic syntax parsing |
 
 ### 🏆 Production Ready
-- **2,675 Tests** - 100% pass rate, enterprise-grade quality assurance
-- **78.85% Coverage** - Comprehensive test coverage
+- **2,831 Tests** - 100% pass rate, enterprise-grade quality assurance
+- **79.19% Coverage** - Comprehensive test coverage
 - **Cross-platform Support** - Compatible with Windows, macOS, Linux
 - **Continuous Maintenance** - Active development and community support
 
@@ -585,7 +592,18 @@ Tree-sitter Analyzer provides a rich set of MCP tools designed for AI assistants
 | **📁 Resource Access** | Code file resources | URI code file access | File content access via URI identification |
 | | Project statistics resources | Project statistics data access | Project analysis data and statistical information |
 
-### 🆕 v1.7.2 New Feature: File Output Optimization
+### 🆕 v1.7.3 New Feature: Complete Markdown Support
+
+Brand new Markdown language support provides powerful capabilities for document analysis and AI assistants:
+
+- **📝 Complete Markdown Parsing**: Support for all major elements including ATX headers, Setext headers, code blocks, links, images, tables
+- **🔍 Intelligent Element Extraction**: Automatically recognize and extract header levels, code languages, link URLs, image information
+- **📊 Structured Analysis**: Convert Markdown documents to structured data for easy AI understanding and processing
+- **🎯 Task List Support**: Complete support for GitHub-style task lists (checkboxes)
+- **🔧 Query System Integration**: Support for all existing query and filtering functionality
+- **📁 Multiple Extension Support**: Support for .md, .markdown, .mdown, .mkd, .mkdn, .mdx formats
+
+### 🆕 v1.7.2 Feature: File Output Optimization
 
 MCP search tools' newly added file output optimization feature is a revolutionary token-saving solution:
 
@@ -709,7 +727,7 @@ uv run python -m tree_sitter_analyzer --show-query-languages
 | **✂️ Intelligent Code Extraction** | Precision Extraction Tool | Precise extraction by line range<br>Preserves original formatting and indentation<br>Includes position metadata<br>Efficient processing of large files | Zero-loss format preservation<br>Memory-optimized algorithms<br>Streaming processing support |
 | **🔍 Advanced Query Filtering** | Multi-dimensional Filters | **Exact match**: `--filter "name=main"`<br>**Pattern match**: `--filter "name=~auth*"`<br>**Parameter filter**: `--filter "params=2"`<br>**Modifier filter**: `--filter "static=true,public=true"`<br>**Compound conditions**: Combine multiple conditions for precise queries | Flexible query syntax<br>High-performance indexing<br>Intelligent caching mechanisms |
 | **🔗 AI Assistant Integration** | MCP Protocol Support | **Claude Desktop** - Full MCP support<br>**Cursor IDE** - Built-in MCP integration<br>**Roo Code** - MCP protocol support<br>**Other MCP-compatible tools** - Universal MCP server | Standard MCP protocol<br>Plug-and-play design<br>Cross-platform compatibility |
-| **🌍 Multi-language Support** | Enterprise Language Engine | **Java** - Complete support, including Spring, JPA frameworks<br>**Python** - Complete support, including type annotations, decorators<br>**JavaScript** - Enterprise-grade support, including ES6+, React/Vue/Angular, JSX<br>**TypeScript** - **Complete support**, including interfaces, types, decorators, TSX/JSX, framework detection<br>**C/C++, Rust, Go** - Basic support | Framework-aware parsing<br>Syntax extension support<br>Continuous language updates |
+| **🌍 Multi-language Support** | Enterprise Language Engine | **Java** - Complete support, including Spring, JPA frameworks<br>**Python** - Complete support, including type annotations, decorators<br>**JavaScript** - Enterprise-grade support, including ES6+, React/Vue/Angular, JSX<br>**TypeScript** - **Complete support**, including interfaces, types, decorators, TSX/JSX, framework detection<br>**Markdown** - **🆕 Complete support**, including headers, code blocks, links, images, tables, task lists, blockquotes<br>**C/C++, Rust, Go** - Basic support | Framework-aware parsing<br>Syntax extension support<br>Continuous language updates |
 | **📁 Advanced File Search** | fd+ripgrep Integration | **ListFilesTool** - Intelligent file discovery with multiple filtering conditions<br>**SearchContentTool** - Intelligent content search using regular expressions<br>**FindAndGrepTool** - Combined discovery and search, two-stage workflow | Rust-based high-performance tools<br>Parallel processing capabilities<br>Intelligent cache optimization |
 | **🏗️ Unified Element System** | Revolutionary Architecture Design | **Single element list** - Unified management of all code elements (classes, methods, fields, imports, packages)<br>**Consistent element types** - Each element has an `element_type` attribute<br>**Simplified API** - Clearer interfaces and reduced complexity<br>**Better maintainability** - Single source of truth for all code elements | Unified data model<br>Type safety guarantees<br>Extensible design |
 
@@ -718,12 +736,18 @@ uv run python -m tree_sitter_analyzer --show-query-languages
 ## 8. 🏆 Quality Assurance
 
 ### 📊 Quality Metrics
-- **2,675 tests** - 100% pass rate ✅
-- **78.85% code coverage** - Comprehensive test suite
+- **2,831 tests** - 100% pass rate ✅
+- **79.19% code coverage** - Comprehensive test suite
 - **Zero test failures** - Production ready
 - **Cross-platform support** - Windows, macOS, Linux
 
-### ⚡ Latest Quality Achievements (v1.7.2)
+### ⚡ Latest Quality Achievements (v1.7.3)
+- ✅ **🆕 Complete Markdown Support** - Added new complete Markdown language plugin supporting all major Markdown elements
+- ✅ **📝 Enhanced Document Analysis** - Support for intelligent extraction of headers, code blocks, links, images, tables, task lists
+- ✅ **🔍 Markdown Query System** - 17 predefined query types with alias and custom query support
+- ✅ **🧪 Comprehensive Test Validation** - Added extensive Markdown test cases ensuring feature stability
+- ✅ **📊 Structured Output** - Convert Markdown documents to structured data for easy AI processing
+- ✅ **🔧 Test Stability Improvement** - Fixed 28 test errors, all 2831 tests now passing 100%
 - ✅ **File output optimization** - MCP search tools now include `suppress_output` and `output_file` parameters for massive token savings
 - ✅ **Intelligent format detection** - Automatic selection of optimal file formats (JSON/Markdown) for storage and reading optimization
 - ✅ **ROO rules documentation** - Added comprehensive tree-sitter-analyzer MCP optimization usage guide