ckgraphify 0.2.1__tar.gz → 0.2.3__tar.gz

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

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

@@ -22,31 +22,6 @@ def _default_graph_path() -> str:
     return str(Path(_GRAPHIFY_OUT) / "graph.json")
 
 
-def _check_skill_version(skill_dst: Path) -> None:
-    """Warn if the installed skill is from an older ckgraphify package version."""
-    version_file = skill_dst.parent / ".ckgraphify_version"
-    if not version_file.exists():
-        return
-    if not skill_dst.exists():
-        print("  warning: skill dir exists but SKILL.md is missing. Run 'graphify install' to repair.")
-        return
-    installed = version_file.read_text(encoding="utf-8").strip()
-    if installed != __version__:
-        print(f"  warning: skill is from ckgraphify {installed}, package is {__version__}. Run 'graphify install' to update.", file=sys.stderr)
-
-
-def _refresh_all_version_stamps() -> None:
-    """After a successful install, update .ckgraphify_version in all other known skill dirs.
-
-    Prevents stale-version warnings from platforms that were installed previously
-    but not explicitly re-installed during this upgrade.
-    """
-    for cfg in _PLATFORM_CONFIG.values():
-        skill_dst = Path.home() / cfg["skill_dst"]
-        vf = skill_dst.parent / ".ckgraphify_version"
-        if skill_dst.exists():
-            vf.write_text(__version__, encoding="utf-8")
-
 _SETTINGS_HOOK = {
     # Claude Code v2.1.117+ removed dedicated Grep/Glob tools; searches now go through Bash.
     # We match on Bash and inspect the command string to avoid firing on every shell call.
@@ -151,10 +126,6 @@ def install(platform: str = "claude") -> None:
             claude_md.parent.mkdir(parents=True, exist_ok=True)
             claude_md.write_text(_SKILL_REGISTRATION.lstrip(), encoding="utf-8")
             print(f"  CLAUDE.md        ->  created at {claude_md}")
-    # Refresh version stamps in all other previously-installed skill dirs so
-    # stale-version warnings don't fire for platforms not explicitly re-installed.
-    _refresh_all_version_stamps()
-
     print()
     print("Done. Open your AI coding assistant and type:")
     print()
@@ -523,15 +494,6 @@ def _clone_repo(url: str, branch: str | None = None, out_dir: Path | None = None
 
 
 def main() -> None:
-    # Check all known skill install locations for a stale version stamp.
-    # Skip during install/uninstall (hook writes trigger a fresh check anyway).
-    # Skip during hook-check — it runs on every editor tool use and must be silent.
-    # Deduplicate paths so platforms sharing the same install dir don't warn twice.
-    _silent_cmds = {"install", "uninstall", "hook-check"}
-    if not any(arg in _silent_cmds for arg in sys.argv):
-        for skill_dst in {Path.home() / cfg["skill_dst"] for cfg in _PLATFORM_CONFIG.values()}:
-            _check_skill_version(skill_dst)
-
     if len(sys.argv) >= 2 and sys.argv[1] in ("-v", "--version", "version"):
         print(f"graphify {__version__}")
         return

{ckgraphify-0.2.1 → ckgraphify-0.2.3}/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: