ckgraphify 0.2.2__tar.gz → 0.2.4__tar.gz

{ckgraphify-0.2.2 → ckgraphify-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ckgraphify
-Version: 0.2.2
+Version: 0.2.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.2.2 → ckgraphify-0.2.4}/graphify/__main__.py

@@ -1588,6 +1588,10 @@ def main() -> None:
                     print("Graph matches:")
                     for cand in result.get("graph_matches", [])[:10]:
                         print(f"- {cand.get('kind')} {cand.get('label')} repo={cand.get('repo') or '-'} score={cand.get('score')}")
+                if result.get("repo_candidates"):
+                    print("Repository routing hints (not evidence):")
+                    for cand in result.get("repo_candidates", [])[:10]:
+                        print(f"- {cand.get('repo_id')} {cand.get('position') or '-'}: {cand.get('reason') or '-'}")
                 print(f"Next action: {result.get('next_action')}")
                 if result.get("trace"):
                     print("")

{ckgraphify-0.2.2 → ckgraphify-0.2.4}/graphify/business_map.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from graphify.graph_main_trace import trace_graph_main
 
 
-_STATUS_ORDER = {"verified": 0, "candidate": 1, "partial": 2, "unexplored": 3, "stale": 4}
+_STATUS_ORDER = {"verified": 0, "boundary": 1, "candidate": 2, "partial": 3, "unexplored": 4, "stale": 5}
 _KG_BANKS_DIR_NAME = "kg-banks"
 _KG_BANKS_ROOT_MARKER = "__root__"
 
@@ -1096,6 +1096,19 @@ def lint_business_map(map_path: Path) -> BusinessLintResult:
         if status == "verified" and require_scope_for_verified and not str(owner.get("verification_scope", "")).strip():
             add("WARN", path, "verified flow should declare verification_scope")
         if status == "verified":
+            has_flow_evidence_navigation = any(
+                isinstance(anchor, dict) and str(anchor.get("ref", "")).strip()
+                for anchor in owner.get("anchors", [])
+            ) or any(
+                isinstance(hint, dict) and str(hint.get("from", "")).strip()
+                for hint in owner.get("trace_hints", [])
+            )
+            if require_scope_for_verified and not has_flow_evidence_navigation:
+                add(
+                    "WARN",
+                    path,
+                    "verified flow has no flow-level anchors or trace_hints; add target-specific evidence navigation or narrow its status/scope",
+                )
             candidate_refs = [
                 str(anchor.get("ref", ""))
                 for anchor in owner.get("anchors", [])
@@ -1446,6 +1459,7 @@ def query_business(
 ) -> dict:
     data = load_business_map(map_path)
     match = match_business_query(data, query, top_k=top_k)
+    repo_candidates = _repo_profile_candidates(map_path.parent / "repo-profiles.json", query, top_k=top_k)
     result: dict = {
         "query": query,
         "map": str(map_path),
@@ -1454,6 +1468,8 @@ def query_business(
         "business_context": _business_context(data, query),
         "trace": None,
         "graph_matches": [],
+        "repo_candidates": repo_candidates,
+        "repo_profile_notice": "Optional routing hints only; not factual evidence. Missing profiles are normal.",
         "next_action": "",
     }
     best = match.get("best")
@@ -1479,3 +1495,60 @@ def query_business(
     if graph_path is not None and match.get("status") == "none":
         result["graph_matches"] = search_graph_main_matches(graph_path, query, top_k=10)
     return result
+
+
+def _repo_profile_candidates(profile_path: Path, query: str, top_k: int = 5) -> list[dict]:
+    """Return deterministic search hints without treating profile text as business evidence."""
+    try:
+        catalog = json.loads(profile_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return []
+    profiles = catalog.get("profiles", []) if isinstance(catalog, dict) else []
+    query_text = str(query or "").strip().lower()
+    if not query_text:
+        return []
+    query_terms = set(_ascii_terms(query_text))
+    candidates: list[tuple[int, str, dict]] = []
+    for profile in profiles if isinstance(profiles, list) else []:
+        if not isinstance(profile, dict):
+            continue
+        fields = {
+            "repo_id": [profile.get("repo_id", "")],
+            "position": [profile.get("position", "")],
+            "aliases": profile.get("aliases", []),
+            "tags": profile.get("tags", []),
+            "capabilities": profile.get("capabilities", []),
+            "summary": [profile.get("summary", "")],
+        }
+        weights = {"repo_id": 12, "position": 10, "aliases": 9, "tags": 7, "capabilities": 6, "summary": 3}
+        score = 0
+        reasons: list[str] = []
+        for field, raw_values in fields.items():
+            values = raw_values if isinstance(raw_values, list) else [raw_values]
+            matched_values: list[str] = []
+            for raw in values:
+                value = str(raw or "").strip()
+                lowered = value.lower()
+                if not lowered:
+                    continue
+                direct = lowered in query_text or query_text in lowered
+                cjk_terms = [term for term in re.findall(r"[\u3400-\u9fff]{2,}", lowered) if term in query_text]
+                term_hit = bool(query_terms.intersection(_ascii_terms(lowered))) or bool(cjk_terms)
+                if direct or term_hit:
+                    score += weights[field] + (3 if direct else 0)
+                    matched_values.append(value)
+            if matched_values:
+                reasons.append(f"{field}: {', '.join(matched_values[:3])}")
+        if score:
+            repo_id = str(profile.get("repo_id", "")).strip()
+            candidates.append((score, repo_id, {
+                "repo_id": repo_id,
+                "position": str(profile.get("position", "")).strip(),
+                "score": score,
+                "reason": "; ".join(reasons),
+                "boundaries": [str(item) for item in profile.get("boundaries", []) if str(item).strip()],
+                "routing_hint_only": True,
+                "supports_factual_claims": False,
+            }))
+    candidates.sort(key=lambda item: (-item[0], item[1]))
+    return [item[2] for item in candidates[:max(1, int(top_k or 5))]]

{ckgraphify-0.2.2 → ckgraphify-0.2.4}/graphify/graph_main_backend.py

@@ -99,7 +99,7 @@ _METAQ_PRODUCER_RE = re.compile(r"(?:Metaq|MetaQ).{0,40}(?:send|publish|produce)
 _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*;'
+    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*\)")
@@ -116,6 +116,10 @@ _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*$"
 )
+_TAG_SPI_EXTENSION_RE = re.compile(r"@TagSpiExtension\s*\((?P<body>.*?)\)", re.S)
+_COMPONENT_TAG_RE = re.compile(r"@ComponentTag\s*\((?P<body>.*?)\)", re.S)
+_BLOCK_EXTENSION_RE = re.compile(r"@BlockExtension\s*\((?P<body>.*?)\)", re.S)
+_ANNOTATION_ARG_RE_TEMPLATE = r"{name}\s*=\s*(?P<value>\{{.*?\}}|\"[^\"]+\"|'[^']+'|[A-Za-z0-9_$.]+)"
 
 
 def _safe_id(s: str) -> str:
@@ -355,6 +359,33 @@ def _resolve_metaq_token(token: str, constants: dict[str, str]) -> str:
     return constants.get(raw) or constants.get(raw.rsplit(".", 1)[-1]) or raw
 
 
+def _resolve_java_string_token(token: str, constants: dict[str, str]) -> str:
+    raw = str(token or "").strip().strip()
+    if not raw:
+        return ""
+    if (raw.startswith('"') and raw.endswith('"')) or (raw.startswith("'") and raw.endswith("'")):
+        return raw[1:-1]
+    return constants.get(raw) or constants.get(raw.rsplit(".", 1)[-1]) or raw
+
+
+def _annotation_arg_values(body: str, name: str, constants: dict[str, str]) -> list[str]:
+    pattern = re.compile(_ANNOTATION_ARG_RE_TEMPLATE.format(name=re.escape(name)), re.S)
+    m = pattern.search(body or "")
+    if not m:
+        return []
+    raw_value = m.group("value").strip()
+    if raw_value.startswith("{") and raw_value.endswith("}"):
+        raw_items = [part.strip() for part in raw_value[1:-1].split(",")]
+    else:
+        raw_items = [raw_value]
+    values: list[str] = []
+    for item in raw_items:
+        resolved = _resolve_java_string_token(item, constants)
+        if resolved:
+            values.append(resolved)
+    return list(dict.fromkeys(values))
+
+
 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]] = []
@@ -1048,6 +1079,7 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
     dep_method_by_key: dict[str, str] = {}
     prod_by_key: dict[str, str] = {}
     cons_by_key: dict[str, str] = {}
+    t3_ext_by_key: dict[str, str] = {}
 
     def ensure_api(interface_fqcn: str, source_file: str, line: int) -> str:
         canonical = f"hsf_api:{interface_fqcn.lower()}"
@@ -1275,6 +1307,51 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
         cons_by_key[canonical] = nid
         return nid
 
+    def ensure_t3_extension(
+        *,
+        extension_type: str,
+        class_fqcn: str,
+        component_code: str,
+        source_file: str,
+        line: int,
+        scene_code: str = "",
+    ) -> str:
+        component_code = component_code.strip()
+        scene_code = scene_code.strip()
+        if not component_code:
+            component_code = "*"
+        key_scene = scene_code.lower() if scene_code else "*"
+        canonical = f"t3_extension:{extension_type}:{key_scene}:{component_code.lower()}:{class_fqcn.lower()}"
+        if canonical in t3_ext_by_key:
+            return t3_ext_by_key[canonical]
+        label_prefix = f"{scene_code}:{component_code}" if scene_code else component_code
+        label = f"{label_prefix} -> {class_fqcn.split('.')[-1]}"
+        nid = f"t3_extension__{_safe_id(extension_type + '_' + label_prefix + '_' + class_fqcn)}"
+        match_key = (
+            f"t3_component:{scene_code.lower()}:{component_code.lower()}"
+            if scene_code and component_code != "*"
+            else f"t3_component:*:{component_code.lower()}"
+        )
+        add_node(
+            {
+                "id": nid,
+                "label": label,
+                "canonical_key": canonical,
+                "match_key": match_key,
+                "file_type": "code",
+                "source_file": source_file,
+                "source_location": f"L{line}",
+                "main_kind": "t3_extension",
+                "extension_type": extension_type,
+                "class_fqcn": class_fqcn,
+                "scene_code": scene_code,
+                "component_code": component_code,
+                "module_code": component_code,
+            }
+        )
+        t3_ext_by_key[canonical] = nid
+        return nid
+
     map_pairs: list[tuple[int, str, str, str]] = []
     mtop_by_method_key: dict[str, str] = {}
     code_method_keys: set[str] = set()
@@ -1299,6 +1376,45 @@ def build_graph_main_backend(*, repo_root: Path, out_path: Path) -> GraphMainBac
             map_method_candidates.add(f"hsf_method:{method_key}")
             map_pairs.append((idx + 1, api_name, iface, method))
 
+    for info in parsed:
+        class_text = _read_text(repo_root / info.rel_path)
+        class_m = _CLASS_RE.search(class_text)
+        class_line = _line_of(class_text, class_m.start()) if class_m else 1
+        for m in _TAG_SPI_EXTENSION_RE.finditer(info.class_ann):
+            scenes = _annotation_arg_values(m.group("body"), "sceneCode", string_constants)
+            modules = _annotation_arg_values(m.group("body"), "moduleCode", string_constants) or [""]
+            for scene in scenes or [""]:
+                for module in modules:
+                    ensure_t3_extension(
+                        extension_type="tag_spi",
+                        class_fqcn=info.class_fqcn,
+                        scene_code=scene,
+                        component_code=module,
+                        source_file=info.rel_path,
+                        line=class_line,
+                    )
+        for m in _COMPONENT_TAG_RE.finditer(info.class_ann):
+            sources = _annotation_arg_values(m.group("body"), "source", string_constants)
+            if not sources:
+                sources = _annotation_arg_values(m.group("body"), "value", string_constants)
+            for source in sources:
+                ensure_t3_extension(
+                    extension_type="component_tag",
+                    class_fqcn=info.class_fqcn,
+                    component_code=source,
+                    source_file=info.rel_path,
+                    line=class_line,
+                )
+        for m in _BLOCK_EXTENSION_RE.finditer(info.class_ann):
+            for code in _annotation_arg_values(m.group("body"), "blockExtensionCode", string_constants):
+                ensure_t3_extension(
+                    extension_type="block_extension",
+                    class_fqcn=info.class_fqcn,
+                    component_code=code,
+                    source_file=info.rel_path,
+                    line=class_line,
+                )
+
     resolved_map_method_keys: set[str] = set()
 
     for info in parsed: