mdengine 0.10.0__tar.gz → 0.11.1__tar.gz

{mdengine-0.10.0 → mdengine-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdengine
-Version: 0.10.0
+Version: 0.11.1
 Summary: Convert PDF, Office, images, audio, video, text/JSON/XML, ZIP archives, web URLs, databases, graphs, and OpenAPI specs to Markdown.
 Author: mdengine contributors
 License-Expression: MIT
@@ -113,6 +113,11 @@ Requires-Dist: openapi-spec-validator>=0.7.0; extra == "openapi"
 Provides-Extra: codeflow
 Requires-Dist: networkx>=3.2.0; extra == "codeflow"
 Requires-Dist: javalang>=0.13.0; extra == "codeflow"
+Provides-Extra: sap
+Requires-Dist: pyyaml>=6.0.0; extra == "sap"
+Requires-Dist: networkx>=3.2.0; extra == "sap"
+Requires-Dist: pydantic>=2.0.0; extra == "sap"
+Requires-Dist: pydantic-settings>=2.0.0; extra == "sap"
 Provides-Extra: codeflow-worker
 Requires-Dist: celery>=5.3.0; extra == "codeflow-worker"
 Requires-Dist: redis>=5.0.0; extra == "codeflow-worker"
@@ -121,6 +126,18 @@ Requires-Dist: tree-sitter>=0.21.0; extra == "codeflow-treesitter"
 Requires-Dist: tree-sitter-javascript>=0.21.0; extra == "codeflow-treesitter"
 Requires-Dist: tree-sitter-typescript>=0.23.0; extra == "codeflow-treesitter"
 Requires-Dist: tree-sitter-cpp>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-java>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-python>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-go>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-php>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-rust>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-kotlin>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-c-sharp>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-swift>=0.7.2; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-ruby>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-lua>=0.2.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-scala>=0.6.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-zig>=0.2.0; extra == "codeflow-treesitter"
 Provides-Extra: codeflow-clang
 Requires-Dist: clang>=16.0.0; extra == "codeflow-clang"
 Provides-Extra: codeflow-semantic
@@ -300,7 +317,7 @@ pip install "mdengine[all]"
 | `openapi` | **OpenAPI / Swagger → Markdown** (`prance`, `openapi-spec-validator`, PyYAML) |
 | `codeflow` | **Static codeflow / call graphs → Markdown** (`networkx`, `javalang`; core scanners) |
 | `codeflow-worker` | Optional **Celery + Redis** workers for the codeflow API async path |
-| `codeflow-treesitter` | **Tree-sitter** parsers (JS/TS/TSX, C++) for richer codeflow slices |
+| `codeflow-treesitter` | **Tree-sitter** parsers (JS/TS/TSX, C++, Java, Python, Go, PHP); use `--parser-mode treesitter` — see [codeflow-to-md/docs/parser-backends.md](codeflow-to-md/docs/parser-backends.md) |
 | `codeflow-clang` | **libclang** bindings for C/C++ parsing when used by the codeflow pipeline |
 | `codeflow-semantic` | **Semantic clustering** (SentenceTransformers, scikit-learn, numpy; large install) |
 | `log` | **Log files → Markdown** (`pandas`, PyYAML, date parsing) |

{mdengine-0.10.0 → mdengine-0.11.1}/README.md

@@ -82,7 +82,7 @@ pip install "mdengine[all]"
 | `openapi` | **OpenAPI / Swagger → Markdown** (`prance`, `openapi-spec-validator`, PyYAML) |
 | `codeflow` | **Static codeflow / call graphs → Markdown** (`networkx`, `javalang`; core scanners) |
 | `codeflow-worker` | Optional **Celery + Redis** workers for the codeflow API async path |
-| `codeflow-treesitter` | **Tree-sitter** parsers (JS/TS/TSX, C++) for richer codeflow slices |
+| `codeflow-treesitter` | **Tree-sitter** parsers (JS/TS/TSX, C++, Java, Python, Go, PHP); use `--parser-mode treesitter` — see [codeflow-to-md/docs/parser-backends.md](codeflow-to-md/docs/parser-backends.md) |
 | `codeflow-clang` | **libclang** bindings for C/C++ parsing when used by the codeflow pipeline |
 | `codeflow-semantic` | **Semantic clustering** (SentenceTransformers, scikit-learn, numpy; large install) |
 | `log` | **Log files → Markdown** (`pandas`, PyYAML, date parsing) |

{mdengine-0.10.0 → mdengine-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mdengine"
-version = "0.10.0"
+version = "0.11.1"
 description = "Convert PDF, Office, images, audio, video, text/JSON/XML, ZIP archives, web URLs, databases, graphs, and OpenAPI specs to Markdown."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -117,6 +117,12 @@ codeflow = [
   "networkx>=3.2.0",
   "javalang>=0.13.0",
 ]
+sap = [
+  "pyyaml>=6.0.0",
+  "networkx>=3.2.0",
+  "pydantic>=2.0.0",
+  "pydantic-settings>=2.0.0",
+]
 # Optional: horizontal workers for codeflow API (Celery + Redis). Default job path uses threads.
 codeflow-worker = [
   "celery>=5.3.0",
@@ -127,6 +133,18 @@ codeflow-treesitter = [
   "tree-sitter-javascript>=0.21.0",
   "tree-sitter-typescript>=0.23.0",
   "tree-sitter-cpp>=0.23.0",
+  "tree-sitter-java>=0.23.0",
+  "tree-sitter-python>=0.23.0",
+  "tree-sitter-go>=0.23.0",
+  "tree-sitter-php>=0.23.0",
+  "tree-sitter-rust>=0.23.0",
+  "tree-sitter-kotlin>=0.23.0",
+  "tree-sitter-c-sharp>=0.23.0",
+  "tree-sitter-swift>=0.7.2",
+  "tree-sitter-ruby>=0.23.0",
+  "tree-sitter-lua>=0.2.0",
+  "tree-sitter-scala>=0.6.0",
+  "tree-sitter-zig>=0.2.0",
 ]
 codeflow-clang = [
   "clang>=16.0.0",
@@ -278,6 +296,9 @@ md-codeflow-mcp = "md_generator.codeflow.api.mcp_server:main"
 md-log = "md_generator.log.cli.main:main"
 md-log-api = "md_generator.log.api.run:main"
 md-log-mcp = "md_generator.log.api.mcp_server:main"
+md-sap = "md_generator.sap.cli.main:main"
+md-sap-api = "md_generator.sap.api.run:main"
+md-sap-mcp = "md_generator.sap.api.mcp_server:main"
 md-otel = "md_generator.otel.cli.main:main"
 mdengine = "md_generator.engine_cli:main"
 
@@ -290,6 +311,7 @@ include = ["md_generator*"]
 "md_generator.graph.config" = ["*.yaml"]
 "md_generator.openapi.config" = ["*.yaml"]
 "md_generator.log.config" = ["*.yaml", "presets/*.yaml"]
+"md_generator.sap.config" = ["*.yaml"]
 "md_generator.tools.assistant" = ["data/**/*"]
 
 [tool.pytest.ini_options]
@@ -313,5 +335,6 @@ testpaths = [
   "openapi-to-md/tests",
   "codeflow-to-md/tests",
   "log-to-md/tests",
+  "sap-to-md/tests",
 ]
 markers = ["integration: optional dependency or slower checks"]

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/__init__.py

@@ -1,5 +1,5 @@
 """md_generator: PDF, Office, image, text, and ZIP to Markdown conversion."""
 
-__version__ = "0.10.0"
+__version__ = "0.11.1"
 
 __all__ = ["__version__"]

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/cli/main.py

@@ -76,6 +76,7 @@ def build_parser() -> argparse.ArgumentParser:
         default="mixed",
         help=(
             "mixed | python | java | javascript | typescript | tsx | cpp | go | php | "
+            "rust | kotlin | csharp | swift | ruby | lua | scala | zig | "
             "comma-separated (e.g. python,javascript). Aliases: js→javascript, ts→typescript."
         ),
     )
@@ -377,7 +378,8 @@ def build_parser() -> argparse.ArgumentParser:
         "--parser-mode",
         choices=("auto", "treesitter", "external"),
         default="auto",
-        help="C++: treesitter=Tree-sitter only; external=clang only; auto=current fallback",
+        help="auto=native parsers; treesitter=Tree-sitter for java/python/go/php/cpp (+ JS/TS when installed); "
+        "external=clang only for C++",
     )
     scan.add_argument(
         "--ui-cfg-max-methods",

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/core/extractor.py

@@ -172,6 +172,22 @@ def _resolve_scan_entry_ids(cfg: ScanConfig, g: CodeflowGraph, all_entries: list
     return entry_ids, warnings
 
 
+def _parse_backend_summary_lines(parse_results: list[FileParseResult]) -> list[str]:
+    from collections import Counter
+
+    counts: Counter[tuple[str, str, str | None]] = Counter()
+    for fr in parse_results:
+        counts[(fr.language, fr.parse_backend, fr.grammar_package)] += 1
+    if not counts:
+        return []
+    lines = ["## Parse backends", ""]
+    for (lang, backend, gram), n in sorted(counts.items()):
+        gpart = f" (`{gram}`)" if gram else ""
+        lines.append(f"- **{lang}** / {backend}{gpart}: {n} file(s)")
+    lines.append("")
+    return lines
+
+
 def _write_scan_summary(
     path: Path,
     *,
@@ -183,6 +199,7 @@ def _write_scan_summary(
     warnings: list[str],
     cfg: ScanConfig,
     pr_impact: dict[str, Any] | None = None,
+    parse_results: list[FileParseResult] | None = None,
 ) -> None:
     lines = [
         "# Scan summary",
@@ -218,6 +235,10 @@ def _write_scan_summary(
         f"- **enable_dependency_graph:** {cfg.enable_dependency_graph}",
         f"- **structural_graph_enabled:** {cfg.structural_graph_enabled()}",
         f"- **parser_mode:** `{cfg.parser_mode}`",
+    ]
+    if parse_results:
+        lines.extend(_parse_backend_summary_lines(parse_results))
+    lines += [
         f"- **ui_cfg_max_methods:** {cfg.ui_cfg_max_methods}",
         f"- **intelligence_transitive_callers:** {cfg.intelligence_transitive_callers}",
         f"- **emit_system_graph_stats:** {cfg.emit_system_graph_stats}",
@@ -448,6 +469,12 @@ def run_scan(cfg: ScanConfig, *, workspace: LoadedWorkspace | None = None) -> Pa
     all_entries = [e for pr in parse_results for e in pr.entries]
     entry_ids, scan_warnings = _resolve_scan_entry_ids(cfg, g, all_entries)
     scan_warnings = scan_warnings_pre + scan_warnings
+    from md_generator.codeflow.parsers.capability_registry import capability_warnings
+
+    for lang in sorted({fr.language for fr in parse_results}):
+        scan_warnings.extend(
+            capability_warnings(lang, parser_mode=cfg.parser_mode, emit_cfg=cfg.emit_cfg),
+        )
     scan_warnings.extend(scan_semantic_warnings)
 
     fmts = {x.strip().lower() for x in cfg.formats}
@@ -920,6 +947,7 @@ def run_scan(cfg: ScanConfig, *, workspace: LoadedWorkspace | None = None) -> Pa
             warnings=scan_warnings,
             cfg=cfg,
             pr_impact=pr_impact_payload,
+            parse_results=parse_results,
         )
 
     return out

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/detectors/api_detector.py

@@ -211,6 +211,117 @@ def detect_api_entries_js_ts(path: Path, project_root: Path) -> list[EntryRecord
     return out
 
 
+_RUBY_CONTROLLER = re.compile(
+    r"class\s+(\w+Controller)\s*<\s*(?:ApplicationController|ActionController)",
+    re.I,
+)
+_RUBY_ROUTE = re.compile(
+    r"\b(get|post|put|patch|delete)\s+['\"]([^'\"]+)['\"]",
+    re.I,
+)
+_SINATRA_ROUTE = re.compile(
+    r"\b(get|post|put|patch|delete)\s+['\"]([^'\"]+)['\"]\s+do\b",
+    re.I,
+)
+_SWIFT_VAPOR = re.compile(r"@\s*(Get|Post|Put|Delete|Patch|Routes)\b")
+
+
+def detect_api_entries_ruby(path: Path, project_root: Path) -> list[EntryRecord]:
+    if path.suffix.lower() != ".rb":
+        return []
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    key = path.resolve().relative_to(project_root.resolve()).as_posix()
+    fp = str(path.resolve())
+    out: list[EntryRecord] = []
+    seen: set[str] = set()
+    for m in _RUBY_CONTROLLER.finditer(text):
+        cls = m.group(1)
+        for dm in re.finditer(rf"\bdef\s+(\w+)", text[m.end() :]):
+            mname = dm.group(1)
+            if mname.startswith("_"):
+                continue
+            sid = _sid(key, cls, mname)
+            if sid in seen:
+                continue
+            seen.add(sid)
+            out.append(
+                EntryRecord(
+                    symbol_id=sid,
+                    kind=EntryKind.API_REST,
+                    label="Rails controller action (regex)",
+                    file_path=fp,
+                    line=text[: m.start() + dm.start()].count("\n") + 1,
+                ),
+            )
+            break
+    for m in _SINATRA_ROUTE.finditer(text):
+        verb, route_path = m.group(1).lower(), m.group(2)
+        sid = f"{key}::sinatra.{verb}.{route_path}"
+        if sid not in seen:
+            seen.add(sid)
+            out.append(
+                EntryRecord(
+                    symbol_id=sid,
+                    kind=EntryKind.API_REST,
+                    label="Sinatra route (regex)",
+                    file_path=fp,
+                    line=text[: m.start()].count("\n") + 1,
+                ),
+            )
+    for m in _RUBY_ROUTE.finditer(text):
+        verb, route_path = m.group(1).lower(), m.group(2)
+        sid = f"{key}::routes.{verb}.{route_path}"
+        if sid not in seen:
+            seen.add(sid)
+            out.append(
+                EntryRecord(
+                    symbol_id=sid,
+                    kind=EntryKind.API_REST,
+                    label=f"Rails route ({verb}) (regex)",
+                    file_path=fp,
+                    line=text[: m.start()].count("\n") + 1,
+                ),
+            )
+    return out
+
+
+def detect_api_entries_swift(path: Path, project_root: Path) -> list[EntryRecord]:
+    if path.suffix.lower() != ".swift":
+        return []
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    if not _SWIFT_VAPOR.search(text):
+        return []
+    key = path.resolve().relative_to(project_root.resolve()).as_posix()
+    fp = str(path.resolve())
+    out: list[EntryRecord] = []
+    seen: set[str] = set()
+    for m in re.finditer(r"func\s+(\w+)\s*\(", text):
+        mname = m.group(1)
+        before = text[max(0, m.start() - 120) : m.start()]
+        if not _SWIFT_VAPOR.search(before):
+            continue
+        sid = _sid(key, None, mname)
+        if sid in seen:
+            continue
+        seen.add(sid)
+        out.append(
+            EntryRecord(
+                symbol_id=sid,
+                kind=EntryKind.API_REST,
+                label="Vapor HTTP route (regex)",
+                file_path=fp,
+                line=text[: m.start()].count("\n") + 1,
+            ),
+        )
+    return out
+
+
 def detect_api_entries(path: Path, project_root: Path) -> list[EntryRecord]:
     suf = path.suffix.lower()
     if suf == ".py":
@@ -219,4 +330,8 @@ def detect_api_entries(path: Path, project_root: Path) -> list[EntryRecord]:
         return detect_api_entries_java(path, project_root)
     if suf in (".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"):
         return detect_api_entries_js_ts(path, project_root)
+    if suf == ".rb":
+        return detect_api_entries_ruby(path, project_root)
+    if suf == ".swift":
+        return detect_api_entries_swift(path, project_root)
     return []

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/detectors/entry_detector.py

@@ -12,6 +12,7 @@ from md_generator.codeflow.config.codeflow_yaml import (
 from md_generator.codeflow.detectors.api_detector import detect_api_entries
 from md_generator.codeflow.detectors.kafka_detector import detect_kafka_entries
 from md_generator.codeflow.detectors.liferay_portlet_detector import detect_liferay_portlet_entries
+from md_generator.codeflow.detectors.rails_detector import detect_rails_entries
 from md_generator.codeflow.models.ir import EntryKind, EntryRecord, FileParseResult
 
 # TYPE_CHECKING would avoid circular import; ScanConfig is lightweight dataclass
@@ -43,6 +44,7 @@ def apply_entry_detectors(
         if not pr:
             continue
         pr.entries.extend(detect_api_entries(p, project_root))
+        pr.entries.extend(detect_rails_entries(p, project_root))
         pr.entries.extend(detect_liferay_portlet_entries(p, project_root, extra_portlet_bases=portlet_extras))
         pr.entries.extend(detect_kafka_entries(p, project_root))
 

mdengine-0.11.1/src/md_generator/codeflow/detectors/rails_detector.py

@@ -0,0 +1,89 @@
+"""Rails router DSL, engines, and ActionCable entry hints."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from md_generator.codeflow.models.ir import EntryKind, EntryRecord
+from md_generator.codeflow.parsers.treesitter_common import rel_key
+
+_HTTP_VERB_ROUTE = re.compile(
+    r"\b(get|post|put|patch|delete|head|options)\s+['\"]([^'\"]+)['\"]",
+    re.IGNORECASE,
+)
+_ROOT_ROUTE = re.compile(r"\broot\s+['\"]?(?:to\s*=>\s*)?['\"]?(\w+#\w+|\w+)", re.IGNORECASE)
+_RESOURCES = re.compile(r"\bresources\s+:([\w]+)")
+_RESOURCE = re.compile(r"\bresource\s+:([\w]+)")
+_NAMESPACE = re.compile(r"\bnamespace\s+:([\w]+)")
+_MOUNT_ENGINE = re.compile(r"\bmount\s+([\w:]+(?:::Engine)?)", re.IGNORECASE)
+_ACTIONCABLE_CHANNEL = re.compile(
+    r"class\s+(\w+)\s*<\s*(?:ApplicationCable::Channel|ActionCable::Channel::Base)",
+    re.IGNORECASE,
+)
+_SUBSCRIBED_METHOD = re.compile(r"\bdef\s+(subscribed|receive|unsubscribed)\b")
+
+
+def detect_rails_entries(path: Path, project_root: Path) -> list[EntryRecord]:
+    if path.suffix.lower() != ".rb":
+        return []
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    key = rel_key(path, project_root)
+    fp = str(path.resolve())
+    out: list[EntryRecord] = []
+    seen: set[str] = set()
+
+    def add(sid: str, label: str, line: int, *, kind: EntryKind = EntryKind.API_REST) -> None:
+        if sid in seen:
+            return
+        seen.add(sid)
+        out.append(
+            EntryRecord(symbol_id=sid, kind=kind, label=label, file_path=fp, line=line),
+        )
+
+    lines = text.splitlines()
+    for i, line in enumerate(lines, start=1):
+        for m in _HTTP_VERB_ROUTE.finditer(line):
+            verb, route_path = m.group(1).lower(), m.group(2)
+            add(
+                f"{key}::routes.{verb}.{route_path}",
+                f"Rails route ({verb.upper()} {route_path})",
+                i,
+            )
+        mroot = _ROOT_ROUTE.search(line)
+        if mroot:
+            add(f"{key}::routes.root.{mroot.group(1)}", "Rails root route", i)
+        for m in _RESOURCES.finditer(line):
+            add(f"{key}::routes.resources.{m.group(1)}", f"Rails resources :{m.group(1)}", i)
+        for m in _RESOURCE.finditer(line):
+            add(f"{key}::routes.resource.{m.group(1)}", f"Rails resource :{m.group(1)}", i)
+        for m in _NAMESPACE.finditer(line):
+            add(f"{key}::routes.namespace.{m.group(1)}", f"Rails namespace :{m.group(1)}", i)
+        for m in _MOUNT_ENGINE.finditer(line):
+            mount_target = m.group(1)
+            add(f"{key}::routes.mount.{mount_target}", f"Rails mount {mount_target}", i)
+
+    if _ACTIONCABLE_CHANNEL.search(text) and _SUBSCRIBED_METHOD.search(text):
+        ch = _ACTIONCABLE_CHANNEL.search(text)
+        cname = ch.group(1) if ch else "Channel"
+        line_no = text[: ch.start()].count("\n") + 1 if ch else 1
+        for m in _SUBSCRIBED_METHOD.finditer(text):
+            mname = m.group(1)
+            add(
+                f"{key}::{cname}.{mname}",
+                f"ActionCable {mname}",
+                text[: m.start()].count("\n") + 1,
+                kind=EntryKind.QUEUE,
+            )
+        if not any(e.symbol_id.endswith(".subscribed") for e in out):
+            add(
+                f"{key}::{cname}.subscribed",
+                "ActionCable channel",
+                line_no,
+                kind=EntryKind.QUEUE,
+            )
+
+    return out

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/lang_dispatch.py

@@ -14,6 +14,14 @@ LANG_EXTENSIONS: dict[str, frozenset[str]] = {
     "cpp": frozenset({".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"}),
     "go": frozenset({".go"}),
     "php": frozenset({".php"}),
+    "rust": frozenset({".rs"}),
+    "kotlin": frozenset({".kt", ".kts"}),
+    "csharp": frozenset({".cs"}),
+    "swift": frozenset({".swift"}),
+    "ruby": frozenset({".rb"}),
+    "lua": frozenset({".lua"}),
+    "scala": frozenset({".scala", ".sc"}),
+    "zig": frozenset({".zig"}),
 }
 
 # All keys used when ``languages`` is ``mixed``
@@ -38,6 +46,14 @@ def normalize_language_filter(languages: str) -> frozenset[str]:
             parts.append("tsx")
         elif p in ("c", "c++", "cxx", "cpp", "cplusplus"):
             parts.append("cpp")
+        elif p == "rs":
+            parts.append("rust")
+        elif p == "kt":
+            parts.append("kotlin")
+        elif p in ("cs", "c#", "csharp"):
+            parts.append("csharp")
+        elif p == "rb":
+            parts.append("ruby")
         else:
             parts.append(p)
     return frozenset(parts) if parts else MIXED_LANG_KEYS

{mdengine-0.10.0 → mdengine-0.11.1}/src/md_generator/codeflow/models/ir.py

@@ -108,10 +108,15 @@ class StructuralEdge:
     line: int | None = None
 
 
+ParseBackend = Literal["native", "treesitter"]
+
+
 @dataclass
 class FileParseResult:
     path: Path
     language: str
+    parse_backend: ParseBackend = "native"
+    grammar_package: str | None = None
     symbol_ids: list[str] = field(default_factory=list)
     calls: list[CallSite] = field(default_factory=list)
     branches: list[BranchPoint] = field(default_factory=list)
@@ -125,3 +130,5 @@ class FileParseResult:
     structural_edges: list[StructuralEdge] = field(default_factory=list)
     # Java compilation unit package (``a.b.c``), for FQN resolution; other languages ignore.
     java_package: str | None = None
+    # Tree-sitter reported syntax errors in the parse tree; partial extraction may still apply.
+    parse_had_errors: bool = False

mdengine-0.11.1/src/md_generator/codeflow/parsers/adapters/treesitter_csharp_adapter.py

@@ -0,0 +1,70 @@
+"""Tree-sitter C# → IRMethod (minimal)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Parser
+
+from md_generator.codeflow.models.ir import FileParseResult
+from md_generator.codeflow.models.ir_cfg import IRMethod, IRStmt
+from md_generator.codeflow.parsers.treesitter_common import decode_text, rel_key, sid
+from md_generator.codeflow.parsers.treesitter_csharp_parser import csharp_language
+
+
+def populate_ir_methods_csharp_treesitter(fr: FileParseResult, project_root: Path) -> None:
+    if fr.parse_backend != "treesitter":
+        fr.ir_methods = []
+        return
+    loaded = csharp_language()
+    if loaded is None:
+        fr.ir_methods = []
+        return
+    lang, _ = loaded
+    source = fr.path.read_bytes()
+    tree = Parser(lang).parse(source)
+    key = rel_key(fr.path, project_root.resolve())
+    fp = str(fr.path.resolve())
+    out: list[IRMethod] = []
+
+    def add_method(node, fq: str | None) -> None:  # noqa: ANN001
+        name = node.child_by_field_name("name")
+        body = node.child_by_field_name("body")
+        if not name:
+            return
+        mname = decode_text(source, name).strip()
+        stmts: tuple[IRStmt, ...] = ()
+        if body:
+            stmts = tuple(
+                IRStmt(kind="STATEMENT", label=c.type, line=c.start_point[0] + 1)
+                for c in body.children
+                if c.is_named
+            )
+        out.append(
+            IRMethod(
+                symbol_id=sid(key, fq, mname),
+                name=mname,
+                file_path=fp,
+                language="csharp",
+                body=stmts,
+            ),
+        )
+
+    def visit_class(node, class_stack: list[str]) -> None:  # noqa: ANN001
+        name = node.child_by_field_name("name")
+        if not name:
+            return
+        class_stack.append(decode_text(source, name).strip())
+        for ch in node.children:
+            if ch.type == "method_declaration":
+                add_method(ch, ".".join(class_stack))
+            elif ch.type == "class_declaration":
+                visit_class(ch, class_stack)
+        class_stack.pop()
+
+    for ch in tree.root_node.children:
+        if ch.type == "class_declaration":
+            visit_class(ch, [])
+        elif ch.type == "method_declaration":
+            add_method(ch, None)
+    fr.ir_methods = out

mdengine-0.11.1/src/md_generator/codeflow/parsers/adapters/treesitter_go_adapter.py

@@ -0,0 +1,58 @@
+"""Tree-sitter Go → IRMethod (minimal)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tree_sitter import Parser
+
+from md_generator.codeflow.models.ir import FileParseResult
+from md_generator.codeflow.models.ir_cfg import IRMethod, IRStmt
+from md_generator.codeflow.parsers.treesitter_common import decode_text, rel_key, sid
+from md_generator.codeflow.parsers.treesitter_go_parser import go_language
+
+
+def populate_ir_methods_go_treesitter(fr: FileParseResult, project_root: Path) -> None:
+    if fr.parse_backend != "treesitter":
+        fr.ir_methods = []
+        return
+    loaded = go_language()
+    if loaded is None:
+        fr.ir_methods = []
+        return
+    lang, _ = loaded
+    source = fr.path.read_bytes()
+    tree = Parser(lang).parse(source)
+    key = rel_key(fr.path, project_root.resolve())
+    fp = str(fr.path.resolve())
+    out: list[IRMethod] = []
+    for ch in tree.root_node.children:
+        if ch.type not in ("function_declaration", "method_declaration"):
+            continue
+        name = ch.child_by_field_name("name")
+        if not name:
+            continue
+        mname = decode_text(source, name).strip()
+        recv = None
+        if ch.type == "method_declaration":
+            recv_n = ch.child_by_field_name("receiver")
+            if recv_n:
+                recv = decode_text(source, recv_n).strip().strip("()")
+        body = ch.child_by_field_name("body")
+        stmts: tuple[IRStmt, ...] = ()
+        if body:
+            stmts = tuple(
+                IRStmt(kind="STATEMENT", label=c.type, line=c.start_point[0] + 1)
+                for c in body.children
+                if c.is_named
+            )
+        out.append(
+            IRMethod(
+                symbol_id=sid(key, recv, mname) if recv else sid(key, None, mname),
+                name=mname,
+                file_path=fp,
+                language="go",
+                body=stmts,
+            ),
+        )
+    fr.ir_methods = out