feat: multi-language support for the encoder and decoder pipelines (#67)

### Summary

This PR extends CoderMind's **encoder** (repository → RPG graph) and
**decoder** (docs → repository) pipelines from Python-only to
**multi-language**, adding support for Python, JavaScript, TypeScript,
Go, C, C++, and Rust.

All language differences are isolated behind two abstraction layers:

- **`lang_parser`** — a tree-sitter–based parser module giving the
encoder uniform code-structure and dependency extraction.
- **`decoder_lang` backends** — one backend per language encapsulating
file layout, entry points, test commands, code structure, and build
environment; every decoder stage (plan / codegen / verification) goes
through these backends.


### Encoder

- New standalone `lang_parser` module (tree-sitter backend + 7 language
parsers/configs) wired into the RPG / dep-graph / encoder pipeline.
- Language metadata flows through `refactor_tree` `NodeMetaData`;
`rpg.json`'s `meta.language` reflects the real repo instead of always
`python`.
- Dominant-language detection; `add_file` and semantic re-runs dispatch
per language; non-Python class-like units normalized.
- `rpg.json` single source of truth (dep_graph embedded); atomic writes
eliminate half-written files.
- C/C++ calls resolve to the definition, not the header prototype; scan
exclusions centralized and per-commit LLM exclusion dropped (perf).

### Decoder

- Seven language backends with a unified protocol: entry points, test
commands, inheritance, code structure, build env, unit-kind.
- **Planning**: language metadata flows through feature spec → build →
tree → skeleton → interfaces → tasks; interface design/review works for
every language with language-neutral prompts; non-Python files ordered
by real imports, not Python AST.
- **Code generation**: codegen / post-verify / global-review /
subtree-review / final-test all route through the backend and use native
test commands (go test, npm, cargo, ctest, …); non-Python projects no
longer emit Python files or run venv/pip setup.
- **Verification**: on-disk source fallback for language resolution;
zero-test "no-op pass" rejected; bounded repair loop in final-test;
unified git branch-name sanitization.
- **Entry coordination**: `<MAIN_ENTRY>` and the skeleton entry are
reconciled across all 7 languages to avoid a duplicate `main`.
- **Interface review** (final fix): unit-level and feature-level orphan
checks unified into a single shared predicate, removing spurious WARNs
on framework roots/factories/callbacks; entry-point name matching
normalized (`RunMain` ↔ `function RunMain`).

---------

Co-authored-by: Qingtao Li <qingtaoli@microsoft.com>

Author: HuYaSen

CoderMind/README.md

@@ -69,7 +69,7 @@ Reverse Direction: Code → RPG                                           │
 │                  │         │  (full)  │       │ (manual  │                 │
 └──────────────────┘         └────┬─────┘       │ fallback)│                 │
                               rpg.json          └──────────┘                 │
-                              dep_graph.json     rpg.json / dep_graph.json   │
+                           (includes dep_graph)          rpg.json              │
                                   │                                          │
                                   └──────────────────────────────────────────┘
                                                   ▲

CoderMind/pyproject.toml

@@ -14,6 +14,16 @@ dependencies = [
     "pytest",
     "tree-sitter",
     "tree-sitter-json",
+    # Tree-sitter grammars for the lang_parser module (Go / TS / JS / C / C++ /
+    # Rust). Installed by default so every language works out of the box; each
+    # is lazy-loaded in lang_parser/tree_sitter_backend.py, so if one grammar
+    # fails to import on a given platform only that language degrades.
+    "tree-sitter-go>=0.23.4",
+    "tree-sitter-typescript>=0.23.2",
+    "tree-sitter-javascript>=0.23.1",
+    "tree-sitter-c>=0.24.2",
+    "tree-sitter-cpp>=0.23.4",
+    "tree-sitter-rust>=0.24.2",
     "networkx",
     "rank_bm25",
     "rapidfuzz",

CoderMind/scripts/build_data_flow.py

@@ -38,6 +38,7 @@
 # Import centralized paths
 from common.paths import SKELETON_FILE, DATA_FLOW_FILE, REPO_RPG_FILE
 from common import get_project_background_context
+from common.language_meta import extract_language_metadata, metadata_with_languages
 
 
 # ============================================================================
@@ -139,6 +140,7 @@ def build(self, skeleton: Dict[str, Any]) -> Dict[str, Any]:
         """
         # Get repository info
         repo_name, repo_info = get_repo_info_from_files()
+        primary_language, _ = extract_language_metadata(skeleton)
 
         # Enrich repo_info with project background / technology context
         project_background = get_project_background_context()
@@ -185,7 +187,8 @@ def build(self, skeleton: Dict[str, Any]) -> Dict[str, Any]:
             max_iterations=self.max_iterations,
             logger=self.logger,
             trajectory=self.trajectory,
-            step_id=self._current_step_id
+            step_id=self._current_step_id,
+            target_language=primary_language,
         )
 
         result = agent.build_data_flow(
@@ -198,6 +201,7 @@ def build(self, skeleton: Dict[str, Any]) -> Dict[str, Any]:
 
         # Add components to result
         result["components"] = functional_areas
+        result["meta"] = metadata_with_languages(skeleton)
 
         # Update trajectory
         if self.trajectory and self._current_step_id:

CoderMind/scripts/build_skeleton.py

@@ -33,6 +33,7 @@
     REPO_RPG_FILE,
 )
 from common import print_unicode_table
+from common.language_meta import extract_language_metadata, metadata_with_languages
 from pathlib import Path as PPath
 from rpg import NodeMetaData
 from skeleton.skeleton_prompts import extract_features_from_subtree
@@ -74,6 +75,12 @@ def convert_node(node):
     output = {
         "repository_name": rpg.repo_name,
         "repository_purpose": rpg.repo_info,
+        "meta": metadata_with_languages({
+            "meta": {
+                "primary_language": getattr(rpg.repo_node.meta, "language", None)
+                if rpg.repo_node and rpg.repo_node.meta else None
+            }
+        }),
         "root": convert_node(skeleton.root),
         "statistics": {
             "total_components": len([n for n in rpg.nodes.values() if n.level == 1]),
@@ -100,6 +107,7 @@ def __init__(self, max_iterations: int = 10, trajectory: Trajectory = None):
 
         # Build state
         self.repo_name = ""
+        self.target_language = None
         self.repo_data = {}
         self.rpg = None
         self.skeleton = None
@@ -121,6 +129,7 @@ def build(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
         """Execute complete skeleton building workflow."""
         self.repo_data = input_data
         self.repo_name = input_data.get("repository_name", "project")
+        self.target_language = extract_language_metadata(input_data)[0]
         components = input_data.get("components", [])
 
         if not components:
@@ -242,7 +251,8 @@ def _step2_file_design(self) -> bool:
                 rpg=self.rpg,
                 max_iterations=self.max_iterations,
                 trajectory=self.trajectory,
-                step_id=self._current_step_id
+                step_id=self._current_step_id,
+                target_language=self.target_language,
             )
 
             # Run file design process
@@ -281,6 +291,12 @@ def _build_result(self) -> Dict[str, Any]:
         """Build the final result dictionary in CoderMind format."""
         # Convert to CoderMind compatible format
         result = convert_skeleton_to_cmind_format(self.skeleton, self.rpg)
+        result["meta"] = metadata_with_languages({
+            "meta": {
+                "primary_language": self.target_language,
+                "target_languages": [self.target_language] if self.target_language else [],
+            }
+        })
 
         # Add statistics
         result["statistics"].update({
@@ -553,7 +569,7 @@ def patch_missing(input_data: Dict[str, Any]) -> Dict[str, Any]:
         json.dump(result, f, indent=2, ensure_ascii=False)
     rpg.save_json(str(REPO_RPG_FILE), indent=2)
 
-    print(f"\n[OK] Patch complete:")
+    print("\n[OK] Patch complete:")
     print(f"  - Missing features patched: {total_missing}")
     print(f"  - New files created: {new_file_count}")
     print(f"  - Features merged into existing files: {merged_count}")

CoderMind/scripts/check_base_classes.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """Check Base Classes Script.
 
-Function: Validate base_classes.json state and validate Python syntax
+Function: Validate base_classes.json state and target-language syntax
 - Checks if base_classes.json exists (init state)
 - Validates JSON structure (error state if invalid)
-- Validates Python code syntax (error state if syntax errors)
+- Validates source syntax (error state if syntax errors)
 - Returns update state if valid
 
 Input: .cmind/base_classes.json
@@ -15,8 +15,9 @@
 from pathlib import Path
 from typing import Dict, Any, List, Tuple
 
-# Import from common utils
-from common import validate_python_syntax, extract_class_names
+from common.language_meta import extract_language_metadata
+from decoder_lang import get_backend
+from func_design.base_class_agent import extract_declaration_names
 
 # Import centralized paths
 from common.paths import BASE_CLASSES_FILE
@@ -34,6 +35,7 @@ def load_json(file_path: Path) -> Dict[str, Any]:
 def validate_base_classes_structure(data: Dict[str, Any]) -> Tuple[bool, List[str]]:
     """Validate base classes structure."""
     errors = []
+    backend = get_backend(extract_language_metadata(data)[0])
 
     base_classes = data.get("base_classes", [])
 
@@ -53,16 +55,15 @@ def validate_base_classes_structure(data: Dict[str, Any]) -> Tuple[bool, List[st
             elif not bc[field]:
                 errors.append(f"Base class {i}: field '{field}' is empty")
 
-        # Validate Python syntax
         code = bc.get("code", "")
         if code:
-            is_valid, error = validate_python_syntax(code)
+            is_valid, error = backend.syntax_check(code, bc.get("file_path", ""))
             if not is_valid:
                 # Try to get name from bc or extract from code
                 name = bc.get("name", "")
                 if not name:
-                    class_names = extract_class_names(code)
-                    name = class_names[0] if class_names else "unknown"
+                    declarations = extract_declaration_names(code, backend)
+                    name = declarations[0] if declarations else "unknown"
                 errors.append(f"Base class {i} ({name}): syntax error - {error}")
 
     # Also validate data_structures if present
@@ -94,11 +95,13 @@ def validate_base_classes_structure(data: Dict[str, Any]) -> Tuple[bool, List[st
 
             code = ds.get("code", "")
             if code:
-                is_valid, error = validate_python_syntax(code)
+                is_valid, error = backend.syntax_check(
+                    code,
+                    ds.get("file_path", f"data_structure{backend.file_extension}"),
+                )
                 if not is_valid:
-                    name = ""
-                    class_names = extract_class_names(code)
-                    name = class_names[0] if class_names else "unknown"
+                    declarations = extract_declaration_names(code, backend)
+                    name = declarations[0] if declarations else "unknown"
                     errors.append(f"Data structure {i} ({name}): syntax error - {error}")
 
     return len(errors) == 0, errors
@@ -172,6 +175,7 @@ def inspect_state(base_classes_path: Path) -> Dict[str, Any]:
             "data_structure_names": ds_class_names,
             "data_structure_subtrees": ds_subtrees,
             "data_structure_file_paths": ds_file_paths,
+            "language": extract_language_metadata(data)[0],
         }
     }
 

CoderMind/scripts/check_code_gen.py

@@ -362,16 +362,53 @@ def determine_state(
         # actually generating the expected files.
         missing_artifacts = []
         repo_root = REPO_DIR
-        
-        # Check for main_entry task artifact
+
+        # Resolve the target language so entry-point / dependency artifact
+        # checks are not hard-coded to Python's ``main.py`` /
+        # ``requirements.txt``. Routes through the canonical repo resolver so
+        # the language is inferred from the real on-disk sources when the rpg
+        # metadata is missing, rather than silently assuming Python. Falls
+        # back to Python on any failure so the check degrades to its previous
+        # behaviour rather than crashing.
+        backend = None
+        try:
+            from common.paths import REPO_RPG_FILE
+            from decoder_lang import resolve_repo_backend
+            rpg_obj = None
+            if Path(REPO_RPG_FILE).is_file():
+                rpg_obj = json.loads(Path(REPO_RPG_FILE).read_text(encoding="utf-8"))
+            backend = resolve_repo_backend(repo_root, rpg_obj=rpg_obj)
+        except Exception:  # noqa: BLE001 — degraded mode: assume Python
+            backend = None
+
+        # Check for main_entry task artifact (language-aware entry path).
         main_entry_ids = [tid for tid in completed_ids if tid.startswith("<MAIN_ENTRY>")]
-        if main_entry_ids and not (repo_root / "main.py").exists():
-            missing_artifacts.append("main.py (from <MAIN_ENTRY> task)")
-        
-        # Check for requirements task artifact
+        if main_entry_ids:
+            if backend is not None:
+                # Accept any of the backend's entry-point shapes. A single
+                # canonical path is too strict when the skeleton placed the
+                # entry off-canonical (e.g. C++ ``src/cli/main.cpp``) or the
+                # language uses a glob convention (Go ``cmd/*/main.go``).
+                candidates = backend.entry_point_candidates()
+                entry_exists = any(
+                    (any(repo_root.glob(c)) if "*" in c else (repo_root / c).exists())
+                    for c in candidates
+                )
+                if not entry_exists:
+                    missing_artifacts.append(
+                        f"{candidates[0]} (from <MAIN_ENTRY> task)"
+                    )
+            elif not (repo_root / "main.py").exists():
+                missing_artifacts.append("main.py (from <MAIN_ENTRY> task)")
+
+        # Check for requirements task artifact. The dependency-manifest
+        # filename is language-specific; only Python's is asserted here
+        # (other languages manage deps via go.mod / Cargo.toml / package.json
+        # which the dependency task and build steps validate separately).
         req_ids = [tid for tid in completed_ids if tid.startswith("<REQUIREMENTS>")]
-        if req_ids and not (repo_root / "requirements.txt").exists():
-            missing_artifacts.append("requirements.txt (from <REQUIREMENTS> task)")
+        if req_ids and (backend is None or backend.name == "python"):
+            if not (repo_root / "requirements.txt").exists():
+                missing_artifacts.append("requirements.txt (from <REQUIREMENTS> task)")
 
         if missing_artifacts:
             result["type"] = "incomplete"

CoderMind/scripts/check_tasks.py

@@ -338,7 +338,10 @@ def check_state(input_path: Path, output_path: Path) -> Dict[str, Any]:
     if not cross_validation["is_consistent"]:
         warning_count = len(cross_validation["warnings"])
         result["type"] = "warning"
-        result["message"] = f"tasks.json exists but has {warning_count} unit mismatches with interfaces."
+        result["message"] = (
+            f"tasks.json exists but has {warning_count} unit mismatches with interfaces. "
+            "This is a cross-stage contract violation; plan.py will rebuild tasks and downstream stages."
+        )
     else:
         result["type"] = "update"
         result["message"] = f"Valid tasks.json exists with {stats['total_tasks']} tasks and {stats['total_units']} units."