atlas-project-harness 0.2.0-beta.2 → 0.2.0-beta.21

package/adapters/api.py

@@ -9,6 +9,10 @@
   `spec_entry`（真相源入口）+ `source_files`，**不产 items**；
 - **无描述** → 从源码抽取端点（`@action` 类 RPC、装饰器路由、**TS 的点分方法名调用**）。
 
+**Java/Spring 形态**（Batch D1）：`@RestController` / `@Controller` 类上的
+`@RequestMapping` 作 base path，方法级 `@GetMapping` / `@PostMapping` / … 组合；
+`@RequestMapping` 未声明动词时记 `ANY`（不猜）。
+
 **TS 的 RPC / action 形态**（2026-10-15 补）：首参是**点分方法名**字符串字面量，形如
 `request('zeldaEasy.platform-console.provider.addProvider', {...})` 或
 `mcpFetch<In, Out>('zeldaEasy.platform-infrastructure.mcp.create', params)`——正是 §3.5
@@ -25,6 +29,7 @@
 from __future__ import annotations
 
 import argparse
+import ast
 import os
 import re
 import sys
@@ -36,11 +41,18 @@ from _lib import (  # noqa: E402
 )
 
 ADAPTER = "api"
-VERSION = "0.2.0"
+VERSION = "0.5.1"
 
 DESCRIPTOR_FILES = {"openapi.json", "openapi.yaml", "openapi.yml", "swagger.json", "swagger.yaml"}
-# 运行时自动生成 schema 的框架信号（框架知识仅允许在适配器出现）
-SCHEMA_MARKERS = (re.compile(r"\bAPIRouter\s*\("), re.compile(r"\bFastAPI\s*\("))
+# 运行时自动生成 schema 的框架信号（框架知识仅允许在适配器出现）。**只认代码里的
+# 构造调用**（AST `Call`）：注释 / 文档字符串 / 正则源码 / 测试夹具里的同名字面量
+# 都不是框架事实（2026-10-29 issue #46：适配器把自己的注释与测试夹具认成了描述源）。
+RUNTIME_SCHEMA_CALLS = ("FastAPI", "APIRouter")
+RUNTIME_SCHEMA_MODULE = "fastapi"
+# 测试文件不是产品接口面：夹具里真起一个 app 也不构成「有描述」
+TEST_PATH_RE = re.compile(
+    r"(?:^|/)(?:tests?|__tests__)/|(?:^|/)test_[^/]*\.py$|(?:^|/)[^/]*_test\.py$|(?:^|/)conftest\.py$"
+)
 DECO_RE = re.compile(r"@(\w+)\.(get|post|put|delete|patch|options|head)\(\s*['\"]([^'\"]*)['\"]")
 PREFIX_RE = re.compile(r"(\w+)\s*=\s*\w+\([^)]*prefix\s*=\s*['\"]([^'\"]+)['\"]")
 JS_RE = re.compile(r"\b(?:app|router)\.(get|post|put|delete|patch)\(\s*['\"]([^'\"]+)['\"]")
@@ -155,6 +167,306 @@ def extract_ts_rpc(root: Path, f: Path) -> list[dict]:
     return items
 
 
+SPRING_VERB_ANN = {
+    "GetMapping": "GET",
+    "PostMapping": "POST",
+    "PutMapping": "PUT",
+    "DeleteMapping": "DELETE",
+    "PatchMapping": "PATCH",
+}
+SPRING_MAPPING_RE = re.compile(
+    r"@(GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping|RequestMapping)\b"
+)
+SPRING_CLASS_RE = re.compile(r"\b(?:class|interface|record|enum)\s+([A-Za-z_]\w*)")
+
+
+def _strip_java_comments(text: str) -> str:
+    out: list[str] = []
+    i, n = 0, len(text)
+    quote = ""
+    in_line = False
+    in_block = False
+    while i < n:
+        if in_line:
+            if text[i] == "\n":
+                in_line = False
+                out.append("\n")
+            else:
+                out.append(" ")
+            i += 1
+            continue
+        if in_block:
+            if text.startswith("*/", i):
+                in_block = False
+                out.append("  ")
+                i += 2
+            else:
+                out.append("\n" if text[i] == "\n" else " ")
+                i += 1
+            continue
+        if quote:
+            out.append(text[i])
+            if text[i] == "\\" and i + 1 < n:
+                out.append(text[i + 1])
+                i += 2
+                continue
+            if text[i] == quote:
+                quote = ""
+            i += 1
+            continue
+        if text.startswith("//", i):
+            in_line = True
+            out.append("  ")
+            i += 2
+            continue
+        if text.startswith("/*", i):
+            in_block = True
+            out.append("  ")
+            i += 2
+            continue
+        if text[i] in "'\"":
+            quote = text[i]
+        out.append(text[i])
+        i += 1
+    return "".join(out)
+
+
+def _quoted(raw: str) -> list[str]:
+    return [m.group(1) for m in re.finditer(r"[\"']([^\"']*)[\"']", raw)]
+
+
+def _spring_paths(args: str) -> list[str]:
+    m = re.search(r"(?:value|path)\s*=\s*(\{[^}]*\}|[\"'][^\"']*[\"'])", args)
+    if m:
+        return _quoted(m.group(1)) or [""]
+    s = args.lstrip()
+    if s.startswith(("\"", "'", "{")):
+        return _quoted(s) or [""]
+    return [""]
+
+
+def _spring_verbs(name: str, args: str) -> list[str]:
+    if name in SPRING_VERB_ANN:
+        return [SPRING_VERB_ANN[name]]
+    verbs = re.findall(r"RequestMethod\.([A-Z]+)", args)
+    return verbs or ["ANY"]
+
+
+def _spring_join(base: str, path: str) -> str:
+    b, p = base.strip(), path.strip()
+    if not b:
+        out = p or "/"
+    elif not p:
+        out = b
+    else:
+        out = b.rstrip("/") + "/" + p.lstrip("/")
+    return out if out.startswith("/") else "/" + out
+
+
+def _spring_mappings(anno: str) -> list[tuple[str, str]]:
+    """annotation 文本 → [(path, verb)]；支持 @@GetMapping 与 @RequestMapping。"""
+    out: list[tuple[str, str]] = []
+    for m in SPRING_MAPPING_RE.finditer(anno):
+        name = m.group(1)
+        start = m.end()
+        # 取该注解的括号参数（不处理嵌套，Spring 映射参数没有嵌套括号）
+        p = anno.find("(", start)
+        if p < 0:
+            args = ""
+        else:
+            q = anno.find(")", p + 1)
+            args = anno[p + 1:q] if q >= 0 else anno[p + 1:]
+        for path in _spring_paths(args):
+            for verb in _spring_verbs(name, args):
+                out.append((path, verb))
+    return out
+
+
+def extract_java_routes(root: Path, f: Path) -> list[dict]:
+    """Spring `@RestController` + `@*Mapping` → api items（框架知识合法落点）。
+
+    类级 `@RequestMapping` 作为 base path；方法级注解组合。`@RequestMapping` 未声明
+    动词时记 `ANY`（不猜成 GET/POST）。只有 `@RestController` / `@Controller` 类才收。
+    """
+    rel = f.relative_to(root).as_posix()
+    text = _strip_java_comments(f.read_text(encoding="utf-8"))
+    lines = text.splitlines()
+    pending: list[tuple[str, int]] = []
+    class_base = [""]
+    is_controller = False
+    items: list[dict] = []
+
+    for lineno, line in enumerate(lines, 1):
+        s = line.strip()
+        if not s:
+            continue
+        if s.startswith("@"):
+            pending.append((s, lineno))
+            continue
+        if SPRING_CLASS_RE.search(s):
+            ann = "\n".join(a for a, _ in pending)
+            is_controller = bool(re.search(r"@(RestController|Controller)\b", ann))
+            # 类级只取 @RequestMapping 的路径；@GetMapping 出现在类上不合法，忽略
+            class_base = [p for p, _ in _spring_mappings(ann)] or [""]
+            pending = []
+            continue
+        if pending and "(" in s:
+            ann = "\n".join(a for a, _ in pending)
+            if is_controller:
+                for path, verb in _spring_mappings(ann):
+                    for base in class_base:
+                        items.append({
+                            "method": verb,
+                            "path": _spring_join(base, path),
+                            "summary": None,
+                            "source_module": rel,
+                            "source_file": f"{rel}:{pending[0][1]}",
+                        })
+            pending = []
+            continue
+        if pending and (";" in s or "}" in s):
+            pending = []
+    return items
+
+
+
+GO_METHOD_RE = re.compile(
+    r"\b\w+\.(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|Any|Get|Post|Put|Delete|Patch|Options|Head)"
+    r"\s*\(\s*\"([^\"]+)\""
+)
+GO_HANDLE_RE = re.compile(
+    r"\b(?:http|mux|router|r)\.(?:HandleFunc|Handle)\s*\(\s*\""
+    r"((?:(?:GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\s+)?[^\"]+)\""
+)
+
+
+def extract_go_routes(root: Path, f: Path) -> list[dict]:
+    """Go 常见路由注册（net/http、gin/echo/chi/fiber 风格）→ api items。
+
+    `r.GET("/x")` 等记动词；`http.HandleFunc("GET /x")` 取前缀动词；无动词记 `ANY`
+    （ServeMux 的旧写法不承载动词，不猜）。`_test.go` 不扫。
+    """
+    rel = f.relative_to(root).as_posix()
+    if f.name.endswith("_test.go"):
+        return []
+    text = strip_js_comments(f.read_text(encoding="utf-8"))
+    items: list[dict] = []
+    for i, ln in enumerate(text.splitlines(), 1):
+        for m in GO_METHOD_RE.finditer(ln):
+            path = m.group(2)
+            # 路由路径必须以 / 开头；q.Get("delay_ms") 这类 query 读取不是路由
+            if not path.startswith("/"):
+                continue
+            method = m.group(1).upper()
+            items.append({
+                "method": method,
+                "path": path,
+                "summary": None,
+                "source_module": rel,
+                "source_file": f"{rel}:{i}",
+            })
+        for m in GO_HANDLE_RE.finditer(ln):
+            raw = m.group(1).strip()
+            parts = raw.split(None, 1)
+            if len(parts) == 2 and parts[0] in (
+                "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"
+            ):
+                method, path = parts[0], parts[1]
+            else:
+                method, path = "ANY", raw
+            if not path.startswith("/"):
+                continue
+            items.append({
+                "method": method,
+                "path": path,
+                "summary": None,
+                "source_module": rel,
+                "source_file": f"{rel}:{i}",
+            })
+    return items
+
+
+
+NEST_CONTROLLER_RE = re.compile(r"@Controller\s*\(\s*(?:['\"]([^'\"]*)['\"])?\s*\)")
+NEST_METHOD_RE = re.compile(
+    r"@(Get|Post|Put|Delete|Patch|Options|Head|All)\s*"
+    r"\(\s*(?:['\"]([^'\"]*)['\"])?\s*\)"
+)
+
+
+def join_nest(prefix: str, path: str) -> str:
+    p, q = prefix.strip(), path.strip()
+    if not p and not q:
+        return "/"
+    if not p:
+        return q if q.startswith("/") else "/" + q
+    if not q:
+        return p if p.startswith("/") else "/" + p
+    out = p.rstrip("/") + "/" + q.lstrip("/")
+    return out if out.startswith("/") else "/" + out
+
+
+def extract_nest_routes(root: Path, f: Path) -> list[dict]:
+    """NestJS / Midway `@Controller` + `@Get/@Post/...` → api items。
+
+    类级 `@Controller('prefix')` 作 base path；方法级 `@All` 记 ANY；无路径参数记空串。
+    只处理含 `@Controller` 的 TS/JS 文件，避免把任意装饰器当路由。
+    """
+    rel = f.relative_to(root).as_posix()
+    text = strip_js_comments(f.read_text(encoding="utf-8"))
+    if "@Controller" not in text:
+        return []
+    items: list[dict] = []
+    prefix: str | None = None
+    for i, line in enumerate(text.splitlines(), 1):
+        cm = NEST_CONTROLLER_RE.search(line)
+        if cm:
+            prefix = cm.group(1) or ""
+            continue
+        if prefix is None:
+            continue
+        m = NEST_METHOD_RE.search(line)
+        if not m:
+            continue
+        method = m.group(1).upper()
+        if method == "ALL":
+            method = "ANY"
+        items.append({
+            "method": method,
+            "path": join_nest(prefix, m.group(2) or ""),
+            "summary": None,
+            "source_module": rel,
+            "source_file": f"{rel}:{i}",
+        })
+    return items
+
+
+def uses_runtime_schema(text: str) -> bool:
+    """文件里是否有**真实的**运行时 schema 构造调用（AST `Call` 节点）。
+
+    字符串 / 注释 / 正则源码不是证据；`from fastapi import FastAPI as App` 的别名也算。
+    解析失败由调用方 WARN 跳过——注释里的字面量曾把适配器自己认成描述源
+    （2026-10-29 issue #46），退回文本匹配会把该缺陷原样带回。
+    """
+    tree = ast.parse(text)
+    names = set(RUNTIME_SCHEMA_CALLS)
+    for node in ast.walk(tree):
+        if (isinstance(node, ast.ImportFrom)
+                and (node.module or "").split(".")[0] == RUNTIME_SCHEMA_MODULE):
+            for a in node.names:
+                if a.name in RUNTIME_SCHEMA_CALLS and a.asname:
+                    names.add(a.asname)
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        fn = node.func
+        if isinstance(fn, ast.Name) and fn.id in names:
+            return True
+        if isinstance(fn, ast.Attribute) and fn.attr in names:
+            return True
+    return False
+
+
 def find_descriptors(root: Path) -> list[str]:
     """按**文件名**找机器可读描述文件（§3.5 的「有描述」探测）。
 
@@ -196,26 +508,37 @@ def main() -> int:
     desc_files: list[str] = find_descriptors(root)
     schema_sources: list[str] = []
     items: list[dict] = []
-    for f in iter_files(root, (".py", ".pyxl", ".js", ".jsx", ".ts", ".tsx"), app_path):
+    for f in iter_files(root, (".py", ".pyxl", ".js", ".jsx", ".ts", ".tsx", ".java", ".go"), app_path):
         rel = f.relative_to(root).as_posix()
         if f.suffix == ".py":
             try:
                 text = f.read_text(encoding="utf-8")
             except OSError:
                 continue
-            if any(mk.search(text) for mk in SCHEMA_MARKERS):
-                schema_sources.append(rel)
+            if not TEST_PATH_RE.search(rel) and any(n in text for n in RUNTIME_SCHEMA_CALLS):
+                try:
+                    if uses_runtime_schema(text):
+                        schema_sources.append(rel)
+                except (SyntaxError, ValueError) as e:
+                    print(f"WARN[{ADAPTER}]: 跳过无法解析的文件 {rel}（运行时 schema 探测）: {e}",
+                          file=sys.stderr)
             items.extend(extract_py_routes(root, f))
         elif f.suffix == ".pyxl":
             items.extend(extract_actions(root, f))
+        elif f.suffix == ".java":
+            items.extend(extract_java_routes(root, f))
+        elif f.suffix == ".go":
+            items.extend(extract_go_routes(root, f))
         else:
             items.extend(extract_js_routes(root, f))
             items.extend(extract_ts_rpc(root, f))
+            items.extend(extract_nest_routes(root, f))
 
     if desc_files or schema_sources:
         # 转指针形态 = 整体丢弃已抽到的 items ⇒ 必须出声，绝不静默清空
-        # （2026-10-15 补：任何 `.py` 文本含 `APIRouter(`/`FastAPI(` 都会走到这里，
-        # 演示脚本也算；不出声的话用户看到的是「接口清单是空的」而无从查因）。
+        # （2026-10-15 补：探测到运行时 schema 信号也会走到这里；2026-10-29 起信号只认
+        # AST 构造调用，注释/字符串/正则源码不再触发——issue #46。不出声的话用户看到的是
+        # 「接口清单是空的」而无从查因）。
         entry = desc_files[0] if desc_files else "/openapi.json"
         if items:
             print(f"WARN[{ADAPTER}]: 探测到机器可读描述（{entry}）⇒ 按 D 类指针形态只记"

package/adapters/models.py

@@ -29,15 +29,21 @@ import re
 import sys
 from pathlib import Path
 
+if str(Path(__file__).resolve().parents[1]) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _support.layout import load_layout  # noqa: E402
+
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from _lib import strip_js_comments  # noqa: E402  # 同包共用工具（引号感知的注释剥离）
+from _jpa import parse_project as parse_jpa_project  # noqa: E402
 
 ADAPTER = "models"
-VERSION = "0.2.0"
+VERSION = "0.5.0"
 
 IGNORE_DIRS = {
     ".git", "node_modules", "__pycache__", "site-packages", "dist", "build",
     ".pyxle-build", ".next", ".turbo", ".mypy_cache", ".pytest_cache", "tests",
+    "target", ".gradle", ".idea", ".scratch", ".atlas", ".atlas-run", ".trellis",
 }
 
 
@@ -61,7 +67,7 @@ def iter_py(root: Path, app_path: str | None):
 
 
 def load_apps(root: Path) -> list[dict]:
-    p = root / "product" / "stack-profile.yaml"
+    p = load_layout(root).stack_profile
     if not p.is_file():
         return []
     apps: list[dict] = []
@@ -521,6 +527,105 @@ def parse_ts_models(src: str) -> tuple[list[dict], list[dict], dict]:
     return items, enums, stats
 
 
+
+def iter_java(root: Path, app_path: str | None):
+    base = root / app_path if app_path else root
+    if not base.exists():
+        return
+    for dirpath, dirnames, filenames in os.walk(base):
+        dirnames[:] = sorted(d for d in dirnames if d not in IGNORE_DIRS and not d.startswith("."))
+        for name in sorted(filenames):
+            if name.endswith(".java"):
+                yield Path(dirpath) / name
+
+
+
+# ------------------------------------------------------------------ Go structs
+
+GO_STRUCT_RE = re.compile(r"\btype\s+(\w+)\s+struct\s*\{([^}]*)\}", re.S)
+GO_FIELD_RE = re.compile(r"^\s*(\w+)\s+([\w\.\*\[\]]+)(?:\s+`([^`]*)`)?\s*$")
+
+
+def _go_tag(tags: str, key: str) -> str:
+    m = re.search(r"(?:^|\s)%s:\"([^\"]*)\"" % re.escape(key), tags or "")
+    return m.group(1) if m else ""
+
+
+def _go_table_name(clean: str, struct: str, tags: str) -> str:
+    m = re.search(
+        r"func\s*\(\s*\w*\s*" + re.escape(struct) +
+        r"\s*\)\s*TableName\(\)\s*string\s*\{\s*return\s*\"([^\"]+)\"",
+        clean,
+    )
+    if m:
+        return m.group(1)
+    tm = _go_tag(tags, "gorm")
+    cm = re.search(r"(?:^|;)column:([^;]+)", tm)
+    return struct
+
+
+def parse_go_models(text: str, rel: str) -> list[dict]:
+    clean = strip_js_comments(text)
+    items: list[dict] = []
+    for m in GO_STRUCT_RE.finditer(clean):
+        struct, body = m.group(1), m.group(2)
+        table = _go_table_name(clean, struct, "")
+        rows: list[dict] = []
+        has_tag = False
+        for line in body.splitlines():
+            fm = GO_FIELD_RE.match(line)
+            if not fm:
+                continue
+            field, typ, tags = fm.group(1), fm.group(2), fm.group(3) or ""
+            has_tag = has_tag or bool(tags.strip())
+            gorm = _go_tag(tags, "gorm")
+            db = _go_tag(tags, "db")
+            js = _go_tag(tags, "json")
+            col = db or (re.search(r"(?:^|;)column:([^;]+)", gorm).group(1)
+                         if re.search(r"(?:^|;)column:([^;]+)", gorm) else "")
+            name = col or (js.split(",")[0] if js else "") or field
+            flags: list[str] = []
+            if "primaryKey" in gorm:
+                flags.append("主键")
+            if "autoIncrement" in gorm:
+                flags.append("自增")
+            if "not null" in gorm:
+                flags.append("非空")
+            if "unique" in gorm:
+                flags.append("唯一")
+            sm = re.search(r"(?:^|;)size:(\d+)", gorm)
+            if sm:
+                flags.append(f"长度={sm.group(1)}")
+            relation = typ if typ.startswith(("*", "[]")) else None
+            rows.append({
+                "table": table,
+                "field": name,
+                "type": typ,
+                "constraints": "，".join(flags) if flags else None,
+                "default": None,
+                "relation": relation,
+                "enum": None,
+                "source_file": rel,
+            })
+        # 无 tag 且无 TableName 的 struct 多为 service/infra，不是数据模型；
+        # 宁可少收，不把 `server{mu,counters}` 这种当表（真实仓烟测暴露）。
+        if not rows or (not has_tag and table == struct):
+            continue
+        items.extend(rows)
+    return items
+
+
+def iter_go(root: Path, app_path: str | None):
+    base = root / app_path if app_path else root
+    if not base.exists():
+        return
+    for dirpath, dirnames, filenames in os.walk(base):
+        dirnames[:] = sorted(d for d in dirnames if d not in IGNORE_DIRS and not d.startswith("."))
+        for name in sorted(filenames):
+            if name.endswith(".go") and not name.endswith("_test.go"):
+                yield Path(dirpath) / name
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__)
     ap.add_argument("--root", required=True)
@@ -598,6 +703,25 @@ def main() -> int:
         print(f"[{ADAPTER}] 统计：顶层枚举/字面量别名声明 {n_enum_decls} 个（自身不成行）；"
               f"字段引用旁表补回取值 {n_alias_refs} 处", file=sys.stderr)
 
+    java_items, java_enums, java_sources = parse_jpa_project(list(iter_java(root, app_path)), root)
+    if java_items:
+        items.extend(java_items)
+        enums.extend(java_enums)
+        source_files.extend(java_sources)
+    for f in iter_go(root, app_path):
+        try:
+            text = f.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        if "type " not in text or "struct" not in text:
+            continue
+        rel = f.relative_to(root).as_posix()
+        file_items = parse_go_models(text, rel)
+        if not file_items:
+            continue
+        source_files.append(rel)
+        items.extend(file_items)
+
     out = {
         "category": "models",
         "items": items,

package/adapters/routes.py

@@ -32,6 +32,10 @@ import re
 import sys
 from pathlib import Path
 
+if str(Path(__file__).resolve().parents[1]) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _support.layout import load_layout  # noqa: E402
+
 ADAPTER = "routes"
 VERSION = "0.3.0"
 
@@ -69,8 +73,8 @@ def iter_files(root: Path, suffixes: tuple[str, ...], app_path: str | None = Non
 
 
 def load_apps(root: Path) -> list[dict]:
-    """从 product/stack-profile.yaml 读 apps（path / role），供状态标注与 --app 过滤。"""
-    p = root / "product" / "stack-profile.yaml"
+    """从资产根/stack-profile.yaml 读 apps（path / role），供状态标注与 --app 过滤。"""
+    p = load_layout(root).stack_profile
     if not p.is_file():
         return []
     apps: list[dict] = []
@@ -731,7 +735,7 @@ def main() -> int:
     if backend == "auto":
         backend = "graph" if cfg else "regex"
     elif backend == "graph" and cfg is None:
-        die("--backend graph 但 profile 未声明 graph 段（先在 product/stack-profile.yaml 声明）")
+        die("--backend graph 但 profile 未声明 graph 段（先在资产根/stack-profile.yaml 声明）")
     relpaths, backend_used, fallback = resolve_relpaths(root, app_path, backend, cfg,
                                                         explicit=args.backend != "auto")
 

package/adapters/tests.py

@@ -33,23 +33,32 @@ from _lib import (  # noqa: E402
 )
 
 ADAPTER = "tests"
-VERSION = "0.2.0"
+VERSION = "0.4.0"
 
 PY_TEST_RE = re.compile(r"^test_.+\.py$|^.+_test\.py$")
 JS_TEST_RE = re.compile(r"\.(spec|test)\.(js|jsx|ts|tsx)$")
+JAVA_TEST_RE = re.compile(r".*(?:Test|Tests|IT)\.java$")
+GO_TEST_RE = re.compile(r".*_test\.go$")
 PYTEST_CONFIG = {"pytest.ini", "tox.ini", "setup.cfg", "pyproject.toml", "conftest.py"}
 PLAYWRIGHT_CONFIG = {"playwright.config.js", "playwright.config.ts"}
 JS_CONFIG = {"vitest.config.js", "vitest.config.ts", "jest.config.js", "jest.config.ts", "package.json"}
+MAVEN_CONFIG = {"pom.xml"}
+GRADLE_CONFIG = {"build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"}
+GO_CONFIG = {"go.mod"}
 
 # 配置探测扫**整项目**（配置是项目级的，不随 app 变）；测试文件盘点按 app 作用域。
-CONFIG_SUFFIXES = (".py", ".ini", ".toml", ".cfg", ".js", ".ts", ".jsx", ".tsx", ".json")
-TEST_SUFFIXES = (".py", ".js", ".jsx", ".ts", ".tsx")
+CONFIG_SUFFIXES = (".py", ".ini", ".toml", ".cfg", ".js", ".ts", ".jsx", ".tsx", ".json", ".xml", ".gradle", ".kts", ".mod")
+TEST_SUFFIXES = (".py", ".js", ".jsx", ".ts", ".tsx", ".java", ".go")
 
 RUN_PYTEST = "python3 -m pytest"
 RUN_PLAYWRIGHT = "npx playwright test"
 RUN_VITEST = "npx vitest run"
 RUN_JEST = "npx jest"
 RUN_NPM = "npm test"
+RUN_MAVEN = "mvn test"
+RUN_GRADLEW = "./gradlew test"
+RUN_GRADLE = "gradle test"
+RUN_GO = "go test ./..."
 
 
 def classify(rel: str, playwright: bool) -> str:
@@ -58,7 +67,7 @@ def classify(rel: str, playwright: bool) -> str:
         return "e2e"
     if playwright and JS_TEST_RE.search(low):
         return "e2e"
-    if "integration" in low:
+    if "integration" in low or low.endswith("it.java"):
         return "integration"
     return "unit"
 
@@ -90,6 +99,9 @@ def main() -> int:
     npm_cfg = False
     vitest_cfg = False
     jest_cfg = False
+    maven_cfg = False
+    gradle_cfg = False
+    go_cfg = False
 
     # ① 配置探测：**整项目范围**。`--app` 下若只扫 app 目录，落在项目根的
     #    `pytest.ini` / `playwright.config.ts` 会被漏掉 ⇒ 逐 app 调用（域级类别的主路径）
@@ -112,14 +124,24 @@ def main() -> int:
                 configs.add(rel)
                 vitest_cfg = vitest_cfg or name.startswith("vitest")
                 jest_cfg = jest_cfg or name.startswith("jest")
+        if name in MAVEN_CONFIG:
+            maven_cfg = True
+            configs.add(rel)
+        if name in GRADLE_CONFIG:
+            gradle_cfg = True
+            configs.add(rel)
+        if name in GO_CONFIG:
+            go_cfg = True
+            configs.add(rel)
 
     # ② 测试文件盘点：app 作用域。
     test_files: list[str] = []
     for f in iter_files(root, TEST_SUFFIXES, app_path):
-        if PY_TEST_RE.match(f.name) or JS_TEST_RE.search(f.name):
+        if PY_TEST_RE.match(f.name) or JS_TEST_RE.search(f.name) or JAVA_TEST_RE.match(f.name) or GO_TEST_RE.match(f.name):
             test_files.append(f.relative_to(root).as_posix())
 
     node_cfg = playwright_cfg or npm_cfg or vitest_cfg or jest_cfg
+    gradle_cmd = RUN_GRADLEW if (root / "gradlew").is_file() else RUN_GRADLE
 
     def runner_for(rel: str) -> tuple[str | None, str | None]:
         """(run_command, 冲突说明)。说明非空 ⇒ run_command 置 null 并打 WARN。
@@ -128,6 +150,22 @@ def main() -> int:
         item 仍出（测试文件存在是事实），命令留空（不作主张），并出声点明。
         完全没配置 ⇒ 命令也留空但**不打 WARN**——那是既有正常形态（契约里 `run_command` 本就可空）。
         """
+        if GO_TEST_RE.match(Path(rel).name):
+            if go_cfg:
+                return RUN_GO, None
+            if pytest_cfg or node_cfg or maven_cfg or gradle_cfg:
+                return None, (f"{rel}：Go 测试文件，但仓里只有其它测试栈配置"
+                              f"（后缀族与配置族冲突，不合成命令）")
+            return None, None
+        if JAVA_TEST_RE.match(Path(rel).name):
+            if maven_cfg:
+                return RUN_MAVEN, None
+            if gradle_cfg:
+                return gradle_cmd, None
+            if pytest_cfg or node_cfg:
+                return None, (f"{rel}：Java 测试文件，但仓里只有 Python/JS 侧测试配置"
+                              f"（后缀族与配置族冲突，不合成命令）")
+            return None, None
         if PY_TEST_RE.match(Path(rel).name):
             if pytest_cfg:
                 return RUN_PYTEST, None