ckgraphify 0.1.3__tar.gz → 0.1.4__tar.gz

{ckgraphify-0.1.3 → ckgraphify-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ckgraphify
-Version: 0.1.3
+Version: 0.1.4
 Summary: AI coding assistant skill for Claude Code and Codex - graph-main boundary graphs, multi-repo call chains, business-map concepts, and business search
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/safishamsi/graphify

{ckgraphify-0.1.3 → ckgraphify-0.1.4}/ckgraphify.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ graphify/global_graph.py
 graphify/google_workspace.py
 graphify/graph_main_backend.py
 graphify/graph_main_frontend.py
+graphify/graph_main_frontend_sdk.py
 graphify/graph_main_html.py
 graphify/graph_main_merge.py
 graphify/graph_main_trace.py
@@ -27,6 +28,7 @@ graphify/hooks.py
 graphify/ingest.py
 graphify/llm.py
 graphify/manifest.py
+graphify/repo_registry.py
 graphify/report.py
 graphify/security.py
 graphify/serve.py

{ckgraphify-0.1.3 → ckgraphify-0.1.4}/graphify/__main__.py

@@ -570,10 +570,11 @@ def main() -> None:
         print("  merge-main-graphs <graph-main.json...>  merge multiple graph-main boundary graphs")
         print("    --out <path>            output path (default: graphify-out/graph-main-merged.json)")
         print("    --report <path>         report path (default: graphify-out/graph-main-merged-report.md)")
+        print("  repo-list [path]         create/update editable repo-list.json from ./repos git remotes")
         print("  main-trace --graph <path> --from <node> [--api <api>] [--max-depth N] [--sources] [--prefer-repo R] [--exclude-repo R]")
         print("                            trace a graph-main chain from an exact entry/API")
-        print("  business-init --concept <name> [--out graphify-out/business-map.json]")
-        print("                            create a business-map seed (currently: 健康卡)")
+        print("  business-init --concept <name> [--out graphify-out/business-map.json] [--force]")
+        print("                            create a business-map or append an unexplored concept")
         print("  business-show [--map <path>] [--concept <name>] [--scenario <name>]")
         print("                            inspect concepts, scenarios, anchors, and trace hints")
         print("  business-query \"question\" [--map <path>] [--graph <path>] [--trace] [--sources] [--format json|text]")
@@ -1357,6 +1358,7 @@ def main() -> None:
             f"repos={stats.repo_count}, nodes={stats.nodes}, edges={stats.edges}, "
             f"cross_edges={stats.cross_edges}, mtop={stats.mtop_links}, rest={stats.rest_links}, "
             f"hsf_method={stats.hsf_method_links}, hsf_api={stats.hsf_api_links}, metaq={stats.metaq_links}, "
+            f"npm_export={stats.npm_export_links}, "
             f"unresolved_dependencies={stats.unresolved_dependencies}"
         )
         print(f"Graph: {out_path}")
@@ -1723,6 +1725,12 @@ def main() -> None:
         args = sys.argv[2:]
         from graphify.business_map import default_business_graph_path, default_business_map_path
 
+        def _require_business_trace_value(option: str, index: int) -> str:
+            if index + 1 >= len(args) or args[index + 1].startswith("--"):
+                print(f"error: business-trace option {option} requires a value", file=sys.stderr)
+                sys.exit(1)
+            return args[index + 1]
+
         map_path = default_business_map_path()
         graph_path: Path | None = None
         concept = ""
@@ -1733,29 +1741,29 @@ def main() -> None:
         i = 0
         while i < len(args):
             a = args[i]
-            if a == "--map" and i + 1 < len(args):
-                map_path = Path(args[i + 1]); i += 2
+            if a == "--map":
+                map_path = Path(_require_business_trace_value(a, i)); i += 2
             elif a.startswith("--map="):
                 map_path = Path(a.split("=", 1)[1]); i += 1
-            elif a == "--graph" and i + 1 < len(args):
-                graph_path = Path(args[i + 1]); i += 2
+            elif a == "--graph":
+                graph_path = Path(_require_business_trace_value(a, i)); i += 2
             elif a.startswith("--graph="):
                 graph_path = Path(a.split("=", 1)[1]); i += 1
-            elif a == "--concept" and i + 1 < len(args):
-                concept = args[i + 1]; i += 2
+            elif a == "--concept":
+                concept = _require_business_trace_value(a, i); i += 2
             elif a.startswith("--concept="):
                 concept = a.split("=", 1)[1]; i += 1
-            elif a == "--scenario" and i + 1 < len(args):
-                scenario = args[i + 1]; i += 2
+            elif a == "--scenario":
+                scenario = _require_business_trace_value(a, i); i += 2
             elif a.startswith("--scenario="):
                 scenario = a.split("=", 1)[1]; i += 1
-            elif a == "--flow" and i + 1 < len(args):
-                flow = args[i + 1]; i += 2
+            elif a == "--flow":
+                flow = _require_business_trace_value(a, i); i += 2
             elif a.startswith("--flow="):
                 flow = a.split("=", 1)[1]; i += 1
-            elif a == "--max-depth" and i + 1 < len(args):
+            elif a == "--max-depth":
                 try:
-                    max_depth = int(args[i + 1])
+                    max_depth = int(_require_business_trace_value(a, i))
                 except ValueError:
                     print("error: --max-depth must be an integer", file=sys.stderr)
                     sys.exit(1)
@@ -1921,6 +1929,22 @@ def main() -> None:
         if thin_out is not None:
             print(f"Thin graph: {thin_out}")
 
+    elif cmd == "repo-list":
+        start = Path(sys.argv[2]) if len(sys.argv) > 2 else Path(".")
+        if len(sys.argv) > 3:
+            print("Usage: graphify repo-list [path]", file=sys.stderr)
+            sys.exit(1)
+        try:
+            from graphify.repo_registry import ensure_repo_list as _ensure_repo_list
+
+            list_path = _ensure_repo_list(start.resolve())
+            data = json.loads(list_path.read_text(encoding="utf-8"))
+            repos = data.get("repos", []) if isinstance(data, dict) else []
+            print(f"Repo list: {list_path} ({len(repos)} repos)")
+        except Exception as exc:
+            print(f"error: repo-list failed: {exc}", file=sys.stderr)
+            sys.exit(1)
+
     elif cmd == "main-graph":
         args = sys.argv[2:]
         root = Path(".")
@@ -2095,7 +2119,8 @@ def main() -> None:
                 print(
                     "Node counts: "
                     f"page={stats.page_nodes}, component={stats.component_nodes}, "
-                    f"mtop_api={stats.mtop_api_nodes}, rest_api={stats.rest_api_nodes}"
+                    f"mtop_api={stats.mtop_api_nodes}, rest_api={stats.rest_api_nodes}, "
+                    f"sdk_export={stats.sdk_export_nodes}, sdk_dependency={stats.sdk_dependency_nodes}"
                 )
                 print(f"HTML: {html_out}")
                 print(f"Report: {report_out}")

{ckgraphify-0.1.3 → ckgraphify-0.1.4}/graphify/business_map.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import re
+import hashlib
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -220,6 +221,49 @@ def health_card_seed() -> dict:
     }
 
 
+def _concept_id_from_name(name: str) -> str:
+    raw = str(name or "").strip()
+    if _matches_text(raw, "健康卡", ["health_card", "healthCard", "health card"]):
+        return "health_card"
+    lowered = raw.lower()
+    if "ai" in lowered and "找药" in raw:
+        return "ai_find_drug"
+    ascii_parts = _ascii_terms(raw)
+    slug = "_".join(ascii_parts)
+    slug = re.sub(r"[^a-z0-9_]+", "_", slug).strip("_")
+    if slug and not slug[0].isdigit():
+        return slug[:48]
+    digest = hashlib.sha1(raw.encode("utf-8")).hexdigest()[:8]
+    return f"concept_{digest}"
+
+
+def concept_seed(concept: str) -> dict:
+    name = str(concept or "").strip()
+    if not name:
+        raise ValueError("concept is required")
+    aliases: list[str] = []
+    if _concept_id_from_name(name) == "ai_find_drug":
+        aliases = ["闪购AI找药", "千问找药"]
+    return {
+        "id": _concept_id_from_name(name),
+        "name": name,
+        "aliases": aliases,
+        "status": "unexplored",
+        "summary": f"待探索{name}相关业务场景、入口、API、后端承接链路和边界。",
+        "scenarios": [],
+        "gaps": ["缺少场景、入口 repo、页面/API 和后端锚点。"],
+    }
+
+
+def _business_map_seed() -> dict:
+    return {
+        "version": 1,
+        "kind": "business-map",
+        "description": "Business concept map layered on top of graph-main facts.",
+        "concepts": [],
+    }
+
+
 def load_business_map(path: Path) -> dict:
     data = json.loads(path.read_text(encoding="utf-8"))
     if not isinstance(data, dict):
@@ -331,11 +375,27 @@ def default_business_graph_path(map_path: Path, start: Path | None = None) -> Pa
 
 
 def init_business_map(concept: str, out_path: Path, *, force: bool = False) -> dict:
-    if out_path.exists() and not force:
-        raise FileExistsError(f"business map already exists: {out_path}")
-    if not _matches_text(concept, "健康卡", ["health_card", "healthCard", "health card"]):
-        raise ValueError(f"unsupported seed concept: {concept}. Currently supported: 健康卡")
-    data = health_card_seed()
+    if force or not out_path.exists():
+        if _matches_text(concept, "健康卡", ["health_card", "healthCard", "health card"]):
+            data = health_card_seed()
+        else:
+            data = _business_map_seed()
+            data["concepts"].append(concept_seed(concept))
+        write_business_map(data, out_path)
+        return data
+
+    data = load_business_map(out_path)
+    concepts = data.setdefault("concepts", [])
+    if not isinstance(concepts, list):
+        raise ValueError("business map concepts must be a list")
+
+    candidate = (
+        health_card_seed()["concepts"][0]
+        if _matches_text(concept, "健康卡", ["health_card", "healthCard", "health card"])
+        else concept_seed(concept)
+    )
+    if not any(isinstance(item, dict) and _concept_matches(item, concept) for item in concepts):
+        concepts.append(candidate)
     write_business_map(data, out_path)
     return data
 

{ckgraphify-0.1.3 → ckgraphify-0.1.4}/graphify/graph_main_backend.py

@@ -7,6 +7,8 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 
+from graphify.repo_registry import repo_metadata_for_root
+
 
 _JAVA_EXTS = {".java"}
 _SKIP_DIRS = {
@@ -96,12 +98,24 @@ _METAQ_CONSUMER_RE = re.compile(r"@(?:MetaqConsumer|MetaQConsumer|MetaqListener|
 _METAQ_PRODUCER_RE = re.compile(r"(?:Metaq|MetaQ).{0,40}(?:send|publish|produce)", re.I | re.S)
 _TOPIC_RE = re.compile(r"""topic\s*=\s*["']([A-Za-z0-9_.-]+)["']""")
 _STR_ASSIGN_RE = re.compile(r'(?m)\bString\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([A-Za-z0-9_.-]+)"\s*;')
+_STATIC_STRING_CONST_RE = re.compile(
+    r'(?m)\b(?:public|protected|private)?\s*static\s+final\s+String\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([^"]+)"\s*;'
+)
 _BINDING_HEADER_RE = re.compile(r"\bBinding\.header\s*\(([^)]*)\)")
 _SET_LISTENER_RE = re.compile(r"\.setMessageListener\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)")
 _ROCKETMQ_CONSUMER_IFACE_RE = re.compile(r"\bMessageListenerConcurrently\b")
 _ROCKETMQ_SEND_CALL_RE = re.compile(r"\.send\s*\(")
 _NEW_MESSAGE_TOPIC_RE = re.compile(r"\bnew\s+Message\s*\(\s*([A-Za-z0-9_$.\"']+)\s*,")
+_MESSAGE_SENDER_SEND_RE = re.compile(
+    r"\b[A-Za-z_][A-Za-z0-9_]*\s*\.\s*sendMessage\s*\(\s*"
+    r"([A-Za-z0-9_$.\"']+)\s*,\s*([A-Za-z0-9_$.\"']+)",
+    re.S,
+)
+_COMPONENT_VALUE_RE = re.compile(r'@(?:Component|Service)\s*\([^)]*(?:value\s*=\s*)?"([^"]+)"')
 _TOPIC_TOKEN_RE = re.compile(r"\b([A-Za-z0-9_$.]*TOPIC[A-Za-z0-9_$.]*)\b")
+_ANTX_CONSUMER_PROP_RE = re.compile(
+    r"(?m)^spring\.metaq\.consumers\[(\d+)\]\.([A-Za-z0-9_.-]+)\s*=\s*(.+?)\s*$"
+)
 
 
 def _safe_id(s: str) -> str:
@@ -314,6 +328,77 @@ def _extract_notify_consumers(body_text: str, fields: tuple["FieldInfo", ...]) -
     return out
 
 
+def _constant_key(package: str, class_name: str, const_name: str) -> str:
+    fqcn = f"{package}.{class_name}" if package else class_name
+    return f"{fqcn}.{const_name}"
+
+
+def _build_string_constant_index(parsed: list["JavaFileInfo"], repo_root: Path) -> dict[str, str]:
+    constants: dict[str, str] = {}
+    for info in parsed:
+        text = _read_text(repo_root / info.rel_path)
+        for m in _STATIC_STRING_CONST_RE.finditer(text):
+            name = m.group(1)
+            value = m.group(2)
+            constants[name] = value
+            constants[f"{info.class_name}.{name}"] = value
+            constants[_constant_key(info.package, info.class_name, name)] = value
+    return constants
+
+
+def _resolve_metaq_token(token: str, constants: dict[str, str]) -> str:
+    raw = str(token or "").strip()
+    if not raw:
+        return ""
+    if raw.startswith('"') and raw.endswith('"') and len(raw) >= 2:
+        return raw[1:-1]
+    return constants.get(raw) or constants.get(raw.rsplit(".", 1)[-1]) or raw
+
+
+def _extract_metaq_producer_topics(body_text: str, constants: dict[str, str] | None = None) -> list[tuple[str, str]]:
+    constants = constants or {}
+    topics: list[tuple[str, str]] = []
+    for m in _NEW_MESSAGE_TOPIC_RE.finditer(body_text):
+        topics.append((_resolve_metaq_token(m.group(1), constants), ""))
+    for m in _MESSAGE_SENDER_SEND_RE.finditer(body_text):
+        topics.append((_resolve_metaq_token(m.group(1), constants), _resolve_metaq_token(m.group(2), constants)))
+    if topics:
+        return list(dict.fromkeys(t for t in topics if t[0]))
+    for m in _TOPIC_TOKEN_RE.finditer(body_text):
+        topics.append((_resolve_metaq_token(m.group(1), constants), ""))
+    return list(dict.fromkeys(t for t in topics if t[0]))
+
+
+def _parse_metaq_consumer_config(repo_root: Path) -> dict[str, dict[str, str]]:
+    by_listener: dict[str, dict[str, str]] = {}
+    candidates = [
+        repo_root / "antx.properties",
+        *repo_root.glob("**/antx.properties"),
+        *repo_root.glob("**/auto-config.xml"),
+    ]
+    for path in candidates:
+        if not path.exists() or path.is_dir():
+            continue
+        text = _read_text(path)
+        grouped: dict[str, dict[str, str]] = {}
+        for m in _ANTX_CONSUMER_PROP_RE.finditer(text):
+            idx = m.group(1)
+            key = m.group(2)
+            value = m.group(3).strip()
+            grouped.setdefault(idx, {})[key] = value
+        for props in grouped.values():
+            listener = props.get("message-listener-ref", "").strip()
+            if not listener:
+                continue
+            by_listener[listener.lower()] = {
+                "topic": props.get("topic", "").strip(),
+                "tag": props.get("sub-expression", "").strip(),
+                "consumer_group": props.get("consumer-group", "").strip(),
+                "config_file": _norm_rel(repo_root, path),
+            }
+    return by_listener
+
+
 def _simple_name(fqcn: str) -> str:
     s = (fqcn or "").strip()
     if not s:
@@ -366,6 +451,11 @@ def _looks_like_local_service_type(fqcn: str) -> bool:
 
 
 def _bean_name_for_class(info: JavaFileInfo) -> str:
+    m = _COMPONENT_VALUE_RE.search(info.class_ann)
+    if m:
+        value = m.group(1).strip()
+        if value:
+            return value
     simple = info.class_name
     if not simple:
         return ""
@@ -501,21 +591,6 @@ def _direct_calls_from_method_body(method: MethodInfo) -> list[tuple[str, int]]:
     return calls
 
 
-def _extract_metaq_producer_topics(body_text: str) -> list[str]:
-    topics: list[str] = []
-    for m in _NEW_MESSAGE_TOPIC_RE.finditer(body_text):
-        tok = m.group(1).strip()
-        if tok.startswith('"') and tok.endswith('"') and len(tok) >= 2:
-            topics.append(tok[1:-1])
-        else:
-            topics.append(tok)
-    if topics:
-        return list(dict.fromkeys(topics))
-    for m in _TOPIC_TOKEN_RE.finditer(body_text):
-        topics.append(m.group(1))
-    return list(dict.fromkeys(topics))
-
-
 def _parse_java_file(rel_path: str, text: str) -> JavaFileInfo | None:
     pkg_m = _PACKAGE_RE.search(text)
     package = pkg_m.group(1) if pkg_m else ""
@@ -755,6 +830,7 @@ def _build_map_impl_report(
 
 def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBackendStats:
     repo_root = repo_root.resolve()
+    repo_meta = repo_metadata_for_root(repo_root)
     files = _iter_java_files(repo_root)
     parsed: list[JavaFileInfo] = []
     for p in files:
@@ -763,6 +839,8 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
         if info:
             parsed.append(info)
 
+    string_constants = _build_string_constant_index(parsed, repo_root)
+    metaq_consumer_config = _parse_metaq_consumer_config(repo_root)
     sdk = _detect_sdk(repo_root, parsed)
     is_sdk = bool(sdk.get("is_sdk_repo"))
     mode = "backend-sdk" if is_sdk else "backend-normal"
@@ -1130,10 +1208,14 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
         dep_method_by_key[canonical] = nid
         return nid
 
-    def ensure_producer(topic: str, source_file: str, line: int) -> str:
+    def ensure_producer(topic: str, source_file: str, line: int, *, tag: str = "") -> str:
         canonical = f"metaq_producer:{topic.lower()}"
         if canonical in prod_by_key:
-            return prod_by_key[canonical]
+            existing_id = prod_by_key[canonical]
+            existing = node_by_id.get(existing_id)
+            if existing is not None and tag and not existing.get("tag"):
+                existing["tag"] = tag
+            return existing_id
         nid = f"metaq_producer__{_safe_id(topic)}"
         add_node(
             {
@@ -1141,6 +1223,7 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
                 "label": topic,
                 "canonical_key": canonical,
                 "topic": topic,
+                "tag": tag,
                 "file_type": "rationale",
                 "source_file": source_file,
                 "source_location": f"L{line}",
@@ -1150,17 +1233,39 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
         prod_by_key[canonical] = nid
         return nid
 
-    def ensure_consumer(topic_or_ref: str, listener_ref: str, source_file: str, line: int) -> str:
+    def ensure_consumer(topic_or_ref: str, listener_ref: str, source_file: str, line: int, *, topic: str = "", tag: str = "", consumer_group: str = "", config_file: str = "") -> str:
         canonical = f"metaq_consumer:{listener_ref.lower()}"
         if canonical in cons_by_key:
-            return cons_by_key[canonical]
+            existing_id = cons_by_key[canonical]
+            existing = node_by_id.get(existing_id)
+            if existing is not None:
+                for key, value in (
+                    ("topic", topic),
+                    ("tag", tag),
+                    ("consumer_group", consumer_group),
+                    ("config_file", config_file),
+                ):
+                    if value and not existing.get(key):
+                        existing[key] = value
+                if topic and existing.get("canonical_key", "").startswith("metaq_consumer:"):
+                    existing["topic_key"] = f"metaq_topic:{topic.lower()}"
+            return existing_id
+        label = listener_ref
+        if not label.endswith("#consumeMessage"):
+            label = f"{listener_ref}#consumeMessage"
         nid = f"metaq_consumer__{_safe_id(listener_ref)}"
         add_node(
             {
                 "id": nid,
-                "label": topic_or_ref,
+                "label": label,
                 "canonical_key": canonical,
+                "topic_key": f"metaq_topic:{topic.lower()}" if topic else "",
+                "topic": topic or topic_or_ref,
+                "tag": tag,
+                "consumer_group": consumer_group,
+                "config_file": config_file,
                 "listener_ref": listener_ref,
+                "listener_class": listener_ref.split("#", 1)[0],
                 "file_type": "rationale",
                 "source_file": source_file,
                 "source_location": f"L{line}",
@@ -1228,14 +1333,17 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
             method_topic = _TOPIC_RE.search(f"{m.ann_text}\n{m.body_text}")
             notify_consumers = _extract_notify_consumers(m.body_text, info.fields)
             rocket_consume_method = bool(class_is_rocket_consumer and m.name == "consumeMessage")
+            bean_name = _bean_name_for_class(info)
+            consumer_cfg = metaq_consumer_config.get(bean_name.lower(), {})
             if rocket_consume_method and not notify_consumers:
-                topic_tokens = _extract_metaq_producer_topics(m.body_text)
-                fallback_topic = topic_tokens[0] if topic_tokens else f"{base_iface}#{m.name}"
+                topic_tokens = _extract_metaq_producer_topics(m.body_text, string_constants)
+                fallback_topic = consumer_cfg.get("topic") or (topic_tokens[0][0] if topic_tokens else f"{base_iface}#{m.name}")
                 notify_consumers = [(fallback_topic, info.class_fqcn)]
-            producer_topics = _extract_metaq_producer_topics(m.body_text)
+            producer_topics = _extract_metaq_producer_topics(m.body_text, string_constants)
             produces_metaq = bool(
                 _METAQ_PRODUCER_RE.search(m.body_text)
                 or (_ROCKETMQ_SEND_CALL_RE.search(m.body_text) and producer_topics)
+                or (_MESSAGE_SENDER_SEND_RE.search(m.body_text) and producer_topics)
             )
             consumes_metaq = bool(_METAQ_CONSUMER_RE.search(m.ann_text) or notify_consumers or rocket_consume_method)
             hsf_dependency_calls = collect_reachable_hsf_deps(info, m)
@@ -1260,14 +1368,15 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
 
             any_kept_method = True
             provider_kind = "sdk_facade" if has_sdk_facade_exposure else "hsf_provider"
+            method_owner = info.class_fqcn if rocket_consume_method else base_iface
             api_nid, method_nid = ensure_provider_method(
-                base_iface,
+                method_owner,
                 m.name,
                 info.rel_path,
                 m.line,
                 provider_kind=provider_kind,
             )
-            method_ck = f"hsf_method:{base_iface.lower()}#{m.name.lower()}"
+            method_ck = f"hsf_method:{method_owner.lower()}#{m.name.lower()}"
             code_method_keys.add(method_ck)
 
             for mtop in method_mtops:
@@ -1327,9 +1436,9 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
                 )
 
             if produces_metaq:
-                topics = producer_topics or ([method_topic.group(1)] if method_topic else [f"{base_iface}#{m.name}"])
-                for topic in topics:
-                    producer_nid = ensure_producer(topic, info.rel_path, m.line)
+                topics = producer_topics or ([(method_topic.group(1), "")] if method_topic else [(f"{base_iface}#{m.name}", "")])
+                for topic, tag in topics:
+                    producer_nid = ensure_producer(topic, info.rel_path, m.line, tag=tag)
                     add_edge(
                         {
                             "source": method_nid,
@@ -1337,6 +1446,8 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
                             "relation": "produces_metaq",
                             "confidence": "INFERRED",
                             "confidence_score": 0.85,
+                            "topic": topic,
+                            "tag": tag,
                             "source_file": info.rel_path,
                             "source_location": f"L{m.line}",
                             "weight": 1.0,
@@ -1346,7 +1457,19 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
             if consumes_metaq:
                 if notify_consumers:
                     for topic, listener in notify_consumers:
-                        consumer_nid = ensure_consumer(topic, listener, info.rel_path, m.line)
+                        cfg = metaq_consumer_config.get(_bean_name_for_class(info).lower(), {})
+                        resolved_topic = cfg.get("topic") or _resolve_metaq_token(topic, string_constants)
+                        tag = cfg.get("tag", "")
+                        consumer_nid = ensure_consumer(
+                            resolved_topic or topic,
+                            listener,
+                            info.rel_path,
+                            m.line,
+                            topic=resolved_topic,
+                            tag=tag,
+                            consumer_group=cfg.get("consumer_group", ""),
+                            config_file=cfg.get("config_file", ""),
+                        )
                         add_edge(
                             {
                                 "source": consumer_nid,
@@ -1354,15 +1477,17 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
                                 "relation": "consumes_metaq",
                                 "confidence": "INFERRED",
                                 "confidence_score": 0.85,
+                                "topic": resolved_topic,
+                                "tag": tag,
                                 "source_file": info.rel_path,
                                 "source_location": f"L{m.line}",
                                 "weight": 1.0,
                             }
                         )
                 else:
-                    topic = method_topic.group(1) if method_topic else f"{base_iface}#{m.name}"
+                    topic = _resolve_metaq_token(method_topic.group(1), string_constants) if method_topic else f"{base_iface}#{m.name}"
                     listener_ref = f"{info.class_fqcn}#{m.name}"
-                    consumer_nid = ensure_consumer(topic, listener_ref, info.rel_path, m.line)
+                    consumer_nid = ensure_consumer(topic, listener_ref, info.rel_path, m.line, topic=topic)
                     add_edge(
                         {
                             "source": consumer_nid,
@@ -1370,6 +1495,7 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
                             "relation": "consumes_metaq",
                             "confidence": "INFERRED",
                             "confidence_score": 0.85,
+                            "topic": topic,
                             "source_file": info.rel_path,
                             "source_location": f"L{m.line}",
                             "weight": 1.0,
@@ -1386,6 +1512,7 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
             "kind": "graph-main-backend",
             "description": "Back-end focused graph (hsf/rest/mtop/dependency/metaq)",
             "repo_name": repo_root.name,
+            "repo": repo_meta,
             "mode": mode,
             "sdk_detection": sdk,
         },