fix: use lfx versions instead of langflow for comp index

scripts/build_component_index.py

@@ -19,11 +19,16 @@
     raise ImportError(msg) from e
 
 
-def _get_langflow_version():
-    """Get the installed langflow version."""
+def _get_lfx_version():
+    """Get the installed lfx version.
+
+    Components are located in LFX, so use LFX.
+    """
     from importlib.metadata import version
 
-    return version("langflow")
+    version = version("lfx")
+    print(f"Retrieved LFX version: {version}")
+    return version
 
 
 def _normalize_for_determinism(obj):
@@ -120,7 +125,7 @@ def _find_component_in_index(index: dict, category: str, component_name: str) ->
 
     for item in index.get("entries", []):
         # Validate entry structure: must be list/tuple with exactly 2 elements
-        if not (isinstance(item, (list, tuple)) and len(item) == entry_tuple_size):
+        if not (isinstance(item, list | tuple) and len(item) == entry_tuple_size):
             msg = f"Invalid index entry format: {item}. Expected {entry_tuple_size}-element list/tuple."
             raise ValueError(msg)
 
@@ -141,8 +146,8 @@ def _find_component_in_index(index: dict, category: str, component_name: str) ->
 METADATA_KEY = "metadata"
 CODE_HASH_KEY = "code_hash"
 HASH_KEY = "hash"  # Key used in hash_history entries
-VERSION_FIRST_KEY = "version_first"
-VERSION_LAST_KEY = "version_last"
+VERSION_FIRST_KEY = "v_from" # Hash valid from Version (inclusive)
+VERSION_LAST_KEY = "v_to" # Hash valid to version (inclusive)
 
 
 def _get_component_hash(component: dict | None) -> str | None:
@@ -252,7 +257,7 @@ def _merge_hash_history(current_component: dict, existing_component: dict | None
     Args:
         current_component: Current component data with code_hash
         existing_component: Existing component from disk
-        current_version: Current Langflow version
+        current_version: Current lfx version
 
     Returns:
         List of hash history entries with version ranges
@@ -329,7 +334,7 @@ def _load_existing_index() -> dict:
 
 
 def _import_components() -> tuple[dict, int]:
-    """Import all Langflow components using the async import function.
+    """Import all lfx components using the async import function.
 
     Returns:
         Tuple of (modules_dict, components_count)
@@ -370,7 +375,7 @@ def build_component_index() -> dict:
 
     existing_index = _load_existing_index()
     modules_dict, components_count = _import_components()
-    current_version = _get_langflow_version()
+    current_version = _get_lfx_version()
 
     # Convert modules_dict to entries format and sort for determinism
     # Sort by category name (top_level) to ensure consistent ordering

src/backend/tests/unit/test_starter_projects_no_hash_history.py

@@ -0,0 +1,87 @@
+"""Test that starter projects do not contain hash_history in their JSON files.
+
+This test ensures that internal component metadata (hash_history) used for tracking
+component evolution in the component index does not leak into saved flow templates.
+"""
+
+import json
+from pathlib import Path
+
+import pytest
+
+
+def find_hash_history_in_dict(data, path=""):
+    """Recursively search for hash_history keys in nested dictionaries.
+
+    Args:
+        data: Dictionary or list to search
+        path: Current path in the data structure (for error reporting)
+
+    Returns:
+        List of paths where hash_history was found
+    """
+    found_paths = []
+
+    if isinstance(data, dict):
+        for key, value in data.items():
+            current_path = f"{path}.{key}" if path else key
+
+            if key == "hash_history":
+                found_paths.append(current_path)
+
+            # Recursively search nested structures
+            found_paths.extend(find_hash_history_in_dict(value, current_path))
+
+    elif isinstance(data, list):
+        for i, item in enumerate(data):
+            current_path = f"{path}[{i}]"
+            found_paths.extend(find_hash_history_in_dict(item, current_path))
+
+    return found_paths
+
+
+def get_starter_project_files():
+    """Get all starter project JSON files."""
+    starter_projects_dir = (
+        Path(__file__).parent.parent.parent / "base" / "langflow" / "initial_setup" / "starter_projects"
+    )
+
+    if not starter_projects_dir.exists():
+        pytest.skip(f"Starter projects directory not found: {starter_projects_dir}")
+
+    json_files = list(starter_projects_dir.glob("*.json"))
+
+    if not json_files:
+        pytest.skip(f"No JSON files found in {starter_projects_dir}")
+
+    return json_files
+
+
+@pytest.mark.parametrize("project_file", get_starter_project_files())
+def test_starter_project_has_no_hash_history(project_file):
+    """Test that a starter project file does not contain hash_history.
+
+    Hash_history is internal metadata for tracking component code evolution
+    and should only exist in component_index.json, never in saved flows.
+    """
+    with project_file.open(encoding="utf-8") as f:
+        project_data = json.load(f)
+
+    # Search for any hash_history keys in the entire project structure
+    hash_history_paths = find_hash_history_in_dict(project_data)
+
+    assert not hash_history_paths, (
+        f"Found hash_history in {project_file.name} at paths: {hash_history_paths}\n"
+        "hash_history is internal component metadata and should not be in saved flows. "
+        "It should only exist in component_index.json for tracking component evolution."
+    )
+
+
+def test_all_starter_projects_loaded():
+    """Sanity check that we're actually testing starter projects."""
+    project_files = get_starter_project_files()
+
+    # We should have multiple starter projects
+    assert len(project_files) > 0, "No starter project files found to test"
+
+    # Print count for visibility