ckgraphify 0.2.3__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ckgraphify
-Version: 0.2.3
+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.3 → 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.3 → 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.3 → ckgraphify-0.2.4}/graphify/graph_main_frontend.py

@@ -37,6 +37,7 @@ _SKIP_DIRS = {
 
 _IMPORT_RE = re.compile(r"""(?m)^\s*import\s+.*?\s+from\s+['"]([^'"]+)['"]""")
 _SIDE_EFFECT_IMPORT_RE = re.compile(r"""(?m)^\s*import\s+['"]([^'"]+)['"]\s*;?\s*$""")
+_EXPORT_FROM_RE = re.compile(r"""(?m)^\s*export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]\s*;?\s*$""")
 _IMPORT_CLAUSE_RE = re.compile(r"""(?m)^\s*import\s+(.+?)\s+from\s+['"]([^'"]+)['"]\s*;?\s*$""")
 _REQUIRE_DECL_RE = re.compile(
     r"""(?m)^\s*(?:const|let|var)\s+(.+?)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)\s*;?\s*$"""
@@ -890,6 +891,15 @@ def _build_local_import_map(repo_root: Path, src_root: Path, code_files: list[Pa
                 imports.add(_norm_rel(repo_root, resolved.resolve()))
             except OSError:
                 continue
+        for m in _EXPORT_FROM_RE.finditer(text):
+            raw_imp = m.group(1).strip()
+            resolved = _resolve_import(p, raw_imp, src_root)
+            if not resolved:
+                continue
+            try:
+                imports.add(_norm_rel(repo_root, resolved.resolve()))
+            except OSError:
+                continue
         out[rel] = imports
     return out
 
@@ -2522,6 +2532,42 @@ def build_graph_main_frontend(*, repo_root: Path, out_path: Path) -> GraphMainFr
     else:
         detection["sdk_detection"] = sdk_detection.as_dict()
         propagated_file_owners = propagate_file_owners(max_depth=3)
+        if mode in {"frontend-normal", "frontend-mixed"}:
+            for rel, (mtop_apis, rest_apis) in file_api_map.items():
+                owners = propagated_file_owners.get(rel, set())
+                if not owners:
+                    continue
+                for owner_nid in sorted(owners):
+                    for api_name in sorted(mtop_apis):
+                        api_nid = ensure_mtop(api_name, rel, "L1")
+                        add_edge(
+                            {
+                                "source": owner_nid,
+                                "target": api_nid,
+                                "relation": "calls_mtop",
+                                "confidence": "EXTRACTED",
+                                "confidence_score": 1.0,
+                                "source_file": rel,
+                                "source_location": "L1",
+                                "weight": 1.0,
+                                "evidence": "reachable_local_import",
+                            }
+                        )
+                    for rest_path in sorted(rest_apis):
+                        rest_nid = ensure_rest(rest_path, rel, "L1")
+                        add_edge(
+                            {
+                                "source": owner_nid,
+                                "target": rest_nid,
+                                "relation": "calls_rest",
+                                "confidence": "EXTRACTED",
+                                "confidence_score": 1.0,
+                                "source_file": rel,
+                                "source_location": "L1",
+                                "weight": 1.0,
+                                "evidence": "reachable_local_import",
+                            }
+                        )
         for dep in collect_sdk_dependencies(repo_root, code_files):
             dep_nid = ensure_sdk_dependency(
                 kind=dep.kind,

{ckgraphify-0.2.3 → ckgraphify-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ckgraphify"
-version = "0.2.3"
+version = "0.2.4"
 description = "AI coding assistant skill for Claude Code and Codex - graph-main boundary graphs, multi-repo call chains, business-map concepts, and business search"
 readme = "README.md"
 license = "MIT"