fastworkflow 2.17.18__py3-none-any.whl → 2.17.20__py3-none-any.whl

fastworkflow/cli.py

@@ -214,12 +214,10 @@ def add_refine_parser(subparsers):
     """Add subparser for the 'refine' command."""
     parser_refine = subparsers.add_parser(
         "refine",
-        help="Refine generated commands: enhance metadata and build dependency graph.",
+        help="Refine generated commands by enhancing metadata.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     parser_refine.add_argument('--workflow-folderpath', '-w', required=True, help='Path to the workflow folder to refine')
-    parser_refine.add_argument('--semantic-threshold', type=float, default=0.85, help='Semantic match threshold for dependency graph')
-    parser_refine.add_argument('--exact-only', action='store_true', help='Use exact name/type matching only for dependency graph')
 
     # Lazy-import refine_main only if the user actually invokes the command
     def _refine_main_wrapper(args):

fastworkflow/refine/__main__.py

@@ -5,12 +5,11 @@ import sys
 import fastworkflow
 from fastworkflow.utils.logging import logger
 from fastworkflow.build.genai_postprocessor import run_genai_postprocessor
-from fastworkflow.utils.command_dependency_graph import generate_dependency_graph
 
 
 def parse_args():
     parser = argparse.ArgumentParser(
-        description="Refine a FastWorkflow by enhancing command metadata and generating dependency graph."
+        description="Refine a FastWorkflow by enhancing command metadata."
     )
     parser.add_argument('--workflow-folderpath', '-w', required=True, help='Path to the workflow folder to refine')
     return parser.parse_args()
@@ -26,24 +25,6 @@ def _validate_workflow_folder(workflow_folderpath: str) -> None:
         sys.exit(1)
 
 
-def _prompt_for_action(non_interactive_choice: int | None = None) -> int:
-    """Prompt user to choose refine action. Returns 1, 2, or 3. Default is 1."""
-    # If a non-interactive choice is provided (e.g., tests), validate and use it
-    if non_interactive_choice in {1, 2, 3}:
-        return int(non_interactive_choice)
-    print("Select refine action:")
-    print("  1) Generate dependency graph (default)")
-    print("  2) Refine command metadata")
-    print("  3) Do both")
-    while True:
-        choice = input("Enter choice [1/2/3]: ").strip()
-        if choice == "":
-            return 1
-        if choice in {"1", "2", "3"}:
-            return int(choice)
-        print("Invalid choice. Please enter 1, 2, or 3.")
-
-
 def refine_main(args):
     """Entry point for the CLI refine command (invoked from fastworkflow.cli)."""
     try:
@@ -53,29 +34,13 @@ def refine_main(args):
         workflow_folderpath = args.workflow_folderpath
         _validate_workflow_folder(workflow_folderpath)
 
-        # Ask user which actions to run (support non-interactive via env var for tests/automation)
-        env_choice = os.environ.get("FASTWORKFLOW_REFINE_CHOICE")
-        try:
-            env_choice_val = int(env_choice) if env_choice is not None else None
-        except ValueError:
-            env_choice_val = None
-        action = _prompt_for_action(non_interactive_choice=env_choice_val)
-
         # Prepare args-like object for post-processor when needed
         class _Dummy:
             pass
         _dummy = _Dummy()
         _dummy.workflow_folderpath = workflow_folderpath
-
-        # Execute selected actions
-        if action in (2, 3):
-            logger.info("Running GenAI metadata refinement with LibCST...")
-            run_genai_postprocessor(_dummy, classes={}, functions={})
-
-        if action in (1, 3):
-            logger.info("Generating parameter dependency graph...")
-            graph_path = generate_dependency_graph(workflow_folderpath)
-            print(f"Generated parameter dependency graph at {graph_path}")
+        logger.info("Running GenAI metadata refinement with LibCST...")
+        run_genai_postprocessor(_dummy, classes={}, functions={})
 
         return 0
     except Exception as e:

fastworkflow/train/__main__.py

@@ -3,6 +3,7 @@ import os
 import json
 import shutil
 from dotenv import dotenv_values
+import importlib.util
 
 from colorama import Fore, Style
 
@@ -16,6 +17,21 @@ from fastworkflow.command_directory import CommandDirectory, get_cached_command_
 from fastworkflow.command_routing import RoutingDefinition, RoutingRegistry
 from fastworkflow.command_context_model import CommandContextModel
 
+# Cache the datasets availability check result
+_DATASETS_AVAILABLE = None
+
+
+def _datasets_available() -> bool:
+    """Check if the datasets package is available in the environment.
+    
+    Returns:
+        bool: True if datasets can be imported, False otherwise.
+    """
+    global _DATASETS_AVAILABLE
+    if _DATASETS_AVAILABLE is None:
+        _DATASETS_AVAILABLE = importlib.util.find_spec("datasets") is not None
+    return _DATASETS_AVAILABLE
+
 
 def train_workflow(workflow_path: str):
     # Ensure context model is parsed so downstream helpers have contexts
@@ -44,6 +60,16 @@ def train_workflow(workflow_path: str):
         logger.info(f"No _commands directory found at {workflow_path}, skipping training")
         return
     
+    # Check if datasets package is available for training
+    # Command directory and routing artifacts are generated above regardless
+    if not _datasets_available():
+        logger.warning(
+            f"datasets package not found in environment. Skipping intent detection training "
+            f"and DSPy few-shot parameter extraction for workflow: {workflow_path}. "
+            f"Other artifacts such as command_directory.json and routing_definition.json have been generated successfully."
+        )
+        return
+    
     # create a workflow and train the main workflow
     workflow = fastworkflow.Workflow.create(
         workflow_path, 

fastworkflow/train/generate_synthetic.py

@@ -1,9 +1,16 @@
 from typing import List
-from datasets import load_dataset
 import random
 import fastworkflow
 import litellm
 
+# Conditional import of datasets - only required at runtime during training
+try:
+    from datasets import load_dataset
+    _DATASETS_AVAILABLE = True
+except ImportError:
+    _DATASETS_AVAILABLE = False
+    load_dataset = None
+
 NUMOF_PERSONAS=fastworkflow.get_env_var('SYNTHETIC_UTTERANCE_GEN_NUMOF_PERSONAS', int)
 UTTERANCES_PER_PERSONA=fastworkflow.get_env_var('SYNTHETIC_UTTERANCE_GEN_UTTERANCES_PER_PERSONA', int)
 PERSONAS_PER_BATCH=fastworkflow.get_env_var('SYNTHETIC_UTTERANCE_GEN_PERSONAS_PER_BATCH', int)
@@ -15,6 +22,15 @@ def generate_diverse_utterances(
     utterances_per_persona: int = UTTERANCES_PER_PERSONA,
     personas_per_batch: int = PERSONAS_PER_BATCH
 ) -> list[str]:
+    # If datasets is not available, return only the seed utterances
+    if not _DATASETS_AVAILABLE:
+        from fastworkflow.utils.logging import logger
+        logger.warning(
+            f"datasets package not available. Skipping synthetic utterance generation "
+            f"for command '{command_name}'. Using only seed utterances."
+        )
+        return [command_name] + seed_utterances
+    
     # Initialize LiteLLM with API key
     api_key = fastworkflow.get_env_var("LITELLM_API_KEY_SYNDATA_GEN")
     model=fastworkflow.get_env_var("LLM_SYNDATA_GEN")

fastworkflow/utils/python_utils.py

@@ -73,13 +73,20 @@ def get_module(module_path: str, search_root: Optional[str] = None) -> Any:
 
         fw_pkg_root = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
 
-        if not (abs_module_path.startswith(project_root) or abs_module_path.startswith(fw_pkg_root)):
+        if abs_module_path.startswith(project_root):
+            relative_base = project_root
+        elif abs_module_path.startswith(fw_pkg_root):
+            relative_base = fw_pkg_root
+        else:
             raise ImportError(
                 f"Module {abs_module_path} is outside of permitted roots: {project_root} or {fw_pkg_root}")
 
         # Build import path relative to project root
-        relative_path = os.path.relpath(abs_module_path, project_root)
+        relative_path = os.path.relpath(abs_module_path, relative_base)
         module_pythonic_path = relative_path.replace(os.sep, ".").rsplit(".py", 1)[0]
+        if relative_base == fw_pkg_root:
+            pkg_name = Path(fw_pkg_root).name
+            module_pythonic_path = f"{pkg_name}.{module_pythonic_path}"
 
         # Use spec_from_file_location for dynamic loading from file paths
         spec = importlib.util.spec_from_file_location(module_pythonic_path, abs_module_path)

fastworkflow/utils/signatures.py

@@ -19,7 +19,6 @@ from fastworkflow.utils.logging import logger
 from fastworkflow.model_pipeline_training import get_route_layer_filepath_model
 from fastworkflow.utils.fuzzy_match import find_best_matches
 from fastworkflow.command_directory import CommandDirectory
-from fastworkflow.utils.command_dependency_graph import get_dependency_suggestions
 
 MISSING_INFORMATION_ERRMSG = None
 INVALID_INFORMATION_ERRMSG = None

{fastworkflow-2.17.18.dist-info → fastworkflow-2.17.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.17.18
+Version: 2.17.20
 Summary: A framework for rapidly building large-scale, deterministic, interactive workflows with a fault-tolerant, conversational UX
 License: Apache-2.0
 Keywords: fastworkflow,ai,workflow,llm,openai
@@ -13,7 +13,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: fastapi
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
-Requires-Dist: datasets (>=4.0.0,<5.0.0)
 Requires-Dist: dspy (>=3.0.1,<4.0.0)
 Requires-Dist: fastapi (>=0.115.5,<0.116.0) ; extra == "fastapi"
 Requires-Dist: fastapi-mcp (>=0.4.0,<0.5.0) ; extra == "fastapi"
@@ -27,7 +26,6 @@ Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0) ; extra == "fastapi"
 Requires-Dist: python-levenshtein (>=0.27.1,<0.28.0)
 Requires-Dist: scikit-learn (>=1.6.1,<2.0.0)
-Requires-Dist: sentence-transformers (>=3.4.1,<4.0.0)
 Requires-Dist: speedict (>=0.3.12,<0.4.0)
 Requires-Dist: torch (>=2.7.1,<3.0.0)
 Requires-Dist: transformers (>=4.48.2,<5.0.0)
@@ -168,6 +166,7 @@ uv pip install fastworkflow
 - `fastWorkflow` currently works on Linux and MacOS only. On windows, use WSL.
 - `fastWorkflow` installs PyTorch as a dependency. If you don't already have PyTorch installed, this could take a few minutes depending on your internet speed.
 - `fastWorkflow` requires Python 3.11+ or higher.
+- Training (`fastworkflow train`) also expects the optional Hugging Face `datasets` package. Install it by including the dev group when using Poetry.
 
 ---
 
@@ -211,6 +210,10 @@ You can get a free API key from [Mistral AI](https://mistral.ai) for the mistral
 
 ### Step 3: Train the Example
 
+> [!note]
+> The training CLI depends on the optional Hugging Face `datasets` package.  
+> Install it explicitly (`pip install datasets`) or, if you're working from this repo, run `poetry install --with dev` before training.
+
 Train the intent-detection models for the workflow:
 
 ```sh

{fastworkflow-2.17.18.dist-info → fastworkflow-2.17.20.dist-info}/RECORD

@@ -36,7 +36,7 @@ fastworkflow/build/pydantic_model_generator.py,sha256=oNyoANyUWBpHG-fE3tGL911RNv
 fastworkflow/build/utterance_generator.py,sha256=UrtkF0wyAZ1hiFitHX0g8w7Wh-D0leLCrP1aUACSfHo,299
 fastworkflow/cache_matching.py,sha256=OoB--1tO6-O4BKCuCrUbB0CkUr76J62K4VAf6MShi-w,7984
 fastworkflow/chat_session.py,sha256=dvRH81Wmj0YCleZaCeWfx9zyqucYCOMJcldhvSLbFeY,35448
-fastworkflow/cli.py,sha256=n-PFDC0EOkq1zIK1Ip44at-VcaP9cW9aSxZ2IVj3VoE,23796
+fastworkflow/cli.py,sha256=Jz8pbs--pgaGU_7H8hjt_ayHbGvvB2HxmJaXamTE9OY,23507
 fastworkflow/command_context_model.py,sha256=bQadDB_IH2lc0br46IT07Iej_j2KrAMderiVKqU7gno,15914
 fastworkflow/command_directory.py,sha256=aJ6UQCwevfF11KbcQB2Qz6mQ7Kj91pZtvHmQY6JFnao,29030
 fastworkflow/command_executor.py,sha256=WTSrukv6UDQfWUDSNleIQ1TxwDnAQIKIimh4sQVwnig,8457
@@ -143,7 +143,7 @@ fastworkflow/examples/simple_workflow_template/startup_action.json,sha256=gj0-B4
 fastworkflow/intent_clarification_agent.py,sha256=VYgpfx7EE0oToewwSaiCdz0VYSFq4Ql0UEsvyXUQhwM,5051
 fastworkflow/mcp_server.py,sha256=NxbLSKf2MA4lAHVcm6ZfiVuOjVO6IeV5Iw17wImFbxQ,8867
 fastworkflow/model_pipeline_training.py,sha256=P_9wrYSfJVSYCTu8VEPkgXJ16eH58LLCK4rCRbRFAVg,46740
-fastworkflow/refine/__main__.py,sha256=bDLpPNMcdp8U4EFnMdjxx1sPDQCZuEJoBURr2KebTng,3398
+fastworkflow/refine/__main__.py,sha256=7r4nVft1inkYQSDrrWD1poS5F8yWuatf98pCp6Lqo7Y,1842
 fastworkflow/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/run/__main__.py,sha256=WMrlkwUt0VTAp_DQwp3LAsJqZlFW63mmVXckuWdMiSo,12077
 fastworkflow/run_fastapi_mcp/README.md,sha256=dAmG2KF-9mqSjyIPSA9vhUit-DjsDH6WJUDCkQ3C1is,11943
@@ -155,12 +155,11 @@ fastworkflow/run_fastapi_mcp/mcp_specific.py,sha256=RdOPcPn68KlxNSM9Vb2yeYEDNGoN
 fastworkflow/run_fastapi_mcp/redoc_2_standalone_html.py,sha256=oYWn30O-xKX6pVjunCeLupyOM2DbeZ3QgFj-F2LalOE,1191
 fastworkflow/run_fastapi_mcp/utils.py,sha256=SX6meWba0T-iYn7YmEajbwJrijfVVUuYGv4usDXzA2c,19589
 fastworkflow/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastworkflow/train/__main__.py,sha256=03OeHVwa7MmBNHGtBrQ-0cT2rtrVtAiQtvQBzkcbp3w,8533
-fastworkflow/train/generate_synthetic.py,sha256=sTDk-E5ewkS4o-0LJeofiEv4uXGpqdGcFRYKY_Yf36Y,5322
+fastworkflow/train/__main__.py,sha256=m4v9uczmZ58EfNlJKc-cewMjPeltLL7tNRKotYtig3o,9532
+fastworkflow/train/generate_synthetic.py,sha256=ingoGxpwlaHGM9WHeK1xULEZntr5HBmQohyLtpqVTD0,5917
 fastworkflow/user_message_queues.py,sha256=svbuFxQ16q6Tz6urPWfD4IEsOTMxtS1Kc1PP8EE8AWg,1422
 fastworkflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/utils/chat_adapter.py,sha256=-U5JFiPynDhSYXJ75wdY0EA-hH8QPaq1bzA6ju4ZnVc,4090
-fastworkflow/utils/command_dependency_graph.py,sha256=7YmAnVXcaLsPVeC3SvM4pGdUsCUxWM4H2qXrtGwQpAI,13512
 fastworkflow/utils/context_utils.py,sha256=mjYVzNJCmimNMmBdOKfzFeDSws_oAADAwcfz_N6sR7M,749
 fastworkflow/utils/dspy_cache_utils.py,sha256=OP2IsWPMGCdhjC-4iRqggWgTEfvPxFN_78tV1_C6uHY,3725
 fastworkflow/utils/dspy_logger.py,sha256=NS40fYl-J-vps82BUh9D8kqv5dP3_qAY78HZWyZemEA,6571
@@ -171,15 +170,15 @@ fastworkflow/utils/generate_param_examples.py,sha256=K0x1Zwe82xqhKA15AYTodWg7mqu
 fastworkflow/utils/logging.py,sha256=2SA-04fg7Lx_vGf980tfCOGDQxBvU9X6Vbhv47rbdaw,4110
 fastworkflow/utils/parameterize_func_decorator.py,sha256=V6YJnishWRCdwiBQW6P17hmGGrga0Empk-AN5Gm7iMk,633
 fastworkflow/utils/pydantic_model_2_dspy_signature_class.py,sha256=w1pvl8rJq48ulFwaAtBgfXYn_SBIDBgq1aLMUg1zJn8,12875
-fastworkflow/utils/python_utils.py,sha256=D0JBdzkwKoyK7XvZcnIxOgsS8CRGdvuW-zcO45_pfOA,8252
+fastworkflow/utils/python_utils.py,sha256=KMxktfIVOre7qkLhd80Ig39g313EMx_I_oHSa6sC5wI,8512
 fastworkflow/utils/react.py,sha256=FGDnzIPKSTwXOCrzUVluFtkZ06lVjgMdB-YQ8jhggZU,13065
-fastworkflow/utils/signatures.py,sha256=uv1HxkVK8yzu6xt0ci8RUSgQW0Njaz22YuJVO_aNUEM,33393
+fastworkflow/utils/signatures.py,sha256=ddcwCLNF_5dpItvcHdkZ0WBMse7CaqYpAyg6WwoJZPo,33310
 fastworkflow/utils/startup_progress.py,sha256=9icSdnpFAxzIq0sUliGpNaH0Efvrt5lDtGfURV5BD98,3539
 fastworkflow/workflow.py,sha256=37gn7e3ct-gdGw43zS6Ab_ADoJJBO4eJW2PywfUpjEg,18825
 fastworkflow/workflow_agent.py,sha256=LRPdl-3lDRPx8pQtK202JWGYMYBNz5Mruy630fCBCk0,18725
 fastworkflow/workflow_inheritance_model.py,sha256=Pp-qSrQISgPfPjJVUfW84pc7HLmL2evuq0UVIYR51K0,7974
-fastworkflow-2.17.18.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fastworkflow-2.17.18.dist-info/METADATA,sha256=xezHaSsRqYq4H9QilU8QxildJOECkMUE6tQxgVFz8CM,30635
-fastworkflow-2.17.18.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastworkflow-2.17.18.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
-fastworkflow-2.17.18.dist-info/RECORD,,
+fastworkflow-2.17.20.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fastworkflow-2.17.20.dist-info/METADATA,sha256=GRA2Txe-gPQQ35HCtWh2NiqLg2f4O5V0apIfEUjZXrY,30915
+fastworkflow-2.17.20.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastworkflow-2.17.20.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
+fastworkflow-2.17.20.dist-info/RECORD,,

fastworkflow/utils/command_dependency_graph.py

@@ -1,364 +0,0 @@
-import json
-import os
-from dataclasses import dataclass
-from typing import Dict, List, Any
-
-from sentence_transformers import SentenceTransformer, util as st_util
-
-# import dspy  # type: ignore
-
-# import fastworkflow  # For env configuration when using DSPy
-from fastworkflow.command_directory import CommandDirectory
-from fastworkflow.command_routing import RoutingDefinition
-from fastworkflow.utils import python_utils
-from fastworkflow.command_metadata_api import CommandMetadataAPI
-
-
-@dataclass
-class ParamMeta:
-    name: str
-    type_str: str
-    description: str
-    examples: List[str]
-
-
-@dataclass
-class CommandParams:
-    inputs: List[ParamMeta]
-    outputs: List[ParamMeta]
-
-
-# def _serialize_type_str(t: Any) -> str:
-#     try:
-#         # Basic serialization for common typing and classes
-#         return t.__name__ if hasattr(t, "__name__") else str(t)
-#     except Exception:
-#         return str(t)
-
-
-def _collect_command_params(workflow_path: str) -> Dict[str, CommandParams]:
-    params_map = CommandMetadataAPI.get_params_for_all_commands(workflow_path)
-
-    results: Dict[str, CommandParams] = {}
-    for qualified_name, io in params_map.items():
-        inputs = [
-            ParamMeta(
-                name=p.get("name", ""),
-                type_str=str(p.get("type_str", "")),
-                description=str(p.get("description", "")),
-                examples=list(p.get("examples", []) or []),
-            )
-            for p in io.get("inputs", [])
-        ]
-        outputs = [
-            ParamMeta(
-                name=p.get("name", ""),
-                type_str=str(p.get("type_str", "")),
-                description=str(p.get("description", "")),
-                examples=list(p.get("examples", []) or []),
-            )
-            for p in io.get("outputs", [])
-        ]
-        # Include all discovered commands; context overlap is handled later
-        results[qualified_name] = CommandParams(inputs=inputs, outputs=outputs)
-
-    return results
-
-
-def _exact_match(out_param: ParamMeta, in_param: ParamMeta) -> bool:
-    return out_param.name.lower() == in_param.name.lower() and out_param.type_str == in_param.type_str
-
-
-def _semantic_match(out_param: ParamMeta, in_param: ParamMeta, threshold: float = 0.85) -> bool:
-    # Sentence Transformers cosine similarity between parameter texts
-    def to_text(p: ParamMeta) -> str:
-        parts = [
-            f"name: {p.name}",
-            f"type: {p.type_str}",
-            f"description: {p.description}",
-            f"examples: {'|'.join(map(str, p.examples))}",
-        ]
-        return " | ".join(parts).lower()
-
-    out_param_text = to_text(out_param)
-    in_param_text = to_text(in_param)
-    if not out_param_text or not in_param_text:
-        return False
-
-    # Lazy-load model and cache embeddings to avoid repeated work
-    global _st_model  # type: ignore
-    global _embedding_cache  # type: ignore
-    if '_st_model' not in globals():
-        _st_model = None  # type: ignore
-    if '_embedding_cache' not in globals():
-        _embedding_cache = {}  # type: ignore
-
-    if _st_model is None:
-        _st_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")  # type: ignore
-
-    if out_param_text not in _embedding_cache:
-        _embedding_cache[out_param_text] = _st_model.encode(
-            out_param_text, convert_to_tensor=True, normalize_embeddings=True
-        )
-    if in_param_text not in _embedding_cache:
-        _embedding_cache[in_param_text] = _st_model.encode(
-            in_param_text, convert_to_tensor=True, normalize_embeddings=True
-        )
-
-    emb_out = _embedding_cache[out_param_text]
-    emb_in = _embedding_cache[in_param_text]
-    sim = st_util.cos_sim(emb_out, emb_in)  # 1x1 tensor
-    return float(sim.item()) >= threshold
-
-
-# ----------------------------------------------------------------------------
-# LLM-based matching using DSPy
-# ----------------------------------------------------------------------------
-
-# Lazy singletons
-# _llm_initialized: bool = False  # type: ignore
-# _llm_module: Optional["CommandDependencyModule"] = None  # type: ignore
-
-
-# def _initialize_dspy_llm_if_needed() -> None:
-#     """Initialize DSPy LM once using FastWorkflow environment.
-
-#     Controlled by env vars:
-#       - LLM_COMMAND_METADATA_GEN (model id for LiteLLM via DSPy)
-#       - LITELLM_API_KEY_COMMANDMETADATA_GEN (API key)
-#     """
-#     global _llm_initialized, _llm_module
-#     if _llm_initialized:
-#         return
-
-#     model = fastworkflow.get_env_var("LLM_COMMAND_METADATA_GEN")
-#     api_key = fastworkflow.get_env_var("LITELLM_API_KEY_COMMANDMETADATA_GEN")
-#     lm = dspy.LM(model=model, api_key=api_key, max_tokens=1000)
-
-#     # Define signature and module only if dspy is available
-#     class CommandDependencySignature(dspy.Signature):  # type: ignore
-#         """Analyze if two commands have a dependency relationship.
-
-#         There is a dependency relationship if and only if the outputs from one command can be used directly as inputs of the other.
-#         Tip for figuring out dependency direction: Commands with hard-to-remember inputs (such as id) typically depend on commands with easy to remember inputs (such as name, email).
-#         """
-
-#         cmd_x_name: str = dspy.InputField(desc="Name of command X")
-#         cmd_x_inputs: str = dspy.InputField(desc="Input parameters of command X (name:type)")
-#         cmd_x_outputs: str = dspy.InputField(desc="Output parameters of command X (name:type)")
-        
-#         cmd_y_name: str = dspy.InputField(desc="Name of command Y")
-#         cmd_y_inputs: str = dspy.InputField(desc="Input parameters of command Y (name:type)")
-#         cmd_y_outputs: str = dspy.InputField(desc="Output parameters of command Y (name:type)")
-
-#         has_dependency: bool = dspy.OutputField(
-#             desc="True if there's a dependency between the commands"
-#         )
-#         direction: str = dspy.OutputField(
-#             desc="Direction: 'x_depends_on_y', 'y_depends_on_x', or 'none'"
-#         )
-
-#     class CommandDependencyModule(dspy.Module):  # type: ignore
-#         def __init__(self):
-#             super().__init__()
-#             self.generate = dspy.ChainOfThought(CommandDependencySignature)
-
-#         def forward(
-#             self,
-#             cmd_x_name: str,
-#             cmd_x_inputs: str,
-#             cmd_x_outputs: str,
-#             cmd_y_name: str,
-#             cmd_y_inputs: str,
-#             cmd_y_outputs: str,
-#         ) -> tuple[bool, str]:
-#             with dspy.context(lm=lm):
-#                 prediction = self.generate(
-#                     cmd_x_name=cmd_x_name,
-#                     cmd_x_inputs=cmd_x_inputs,
-#                     cmd_x_outputs=cmd_x_outputs,
-#                     cmd_y_name=cmd_y_name,
-#                     cmd_y_inputs=cmd_y_inputs,
-#                     cmd_y_outputs=cmd_y_outputs,
-#                 )
-#                 return prediction.has_dependency, prediction.direction
-
-#     _llm_module = CommandDependencyModule()
-#     _llm_initialized = True
-
-
-# def _llm_command_dependency(
-#     cmd_x_name: str, 
-#     cmd_x_params: CommandParams,
-#     cmd_y_name: str,
-#     cmd_y_params: CommandParams
-# ) -> Optional[str]:
-#     """Check if two commands have a dependency using LLM.
-    
-#     Returns:
-#         - "x_to_y" if Y depends on X (X's outputs feed Y's inputs)
-#         - "y_to_x" if X depends on Y (Y's outputs feed X's inputs)  
-#         - None if no dependency
-#     """
-#     _initialize_dspy_llm_if_needed()
-
-#     # Format parameters for LLM
-#     x_inputs = ", ".join([f"{p.name}:{p.type_str}" for p in cmd_x_params.inputs])
-#     x_outputs = ", ".join([f"{p.name}:{p.type_str}" for p in cmd_x_params.outputs])
-#     y_inputs = ", ".join([f"{p.name}:{p.type_str}" for p in cmd_y_params.inputs])
-#     y_outputs = ", ".join([f"{p.name}:{p.type_str}" for p in cmd_y_params.outputs])
-
-#     has_dep, direction = _llm_module(
-#         cmd_x_name=cmd_x_name,
-#         cmd_x_inputs=x_inputs or "none",
-#         cmd_x_outputs=x_outputs or "none",
-#         cmd_y_name=cmd_y_name,
-#         cmd_y_inputs=y_inputs or "none",
-#         cmd_y_outputs=y_outputs or "none",
-#     )
-
-#     if not has_dep or direction == "none":
-#         return None
-#     if direction == "x_depends_on_y":
-#         return "y_to_x"  # Y's outputs -> X's inputs
-#     return "x_to_y" if direction == "y_depends_on_x" else None
-
-
-def _contexts_overlap(routing: RoutingDefinition, cmd_x: str, cmd_y: str) -> bool:
-    cx = routing.get_contexts_for_command(cmd_x)
-    cy = routing.get_contexts_for_command(cmd_y)
-    return False if not cx or not cy else bool(cx & cy)
-
-
-def _check_param_dependencies(
-    outputs: List[ParamMeta], 
-    inputs: List[ParamMeta],
-    semantic_threshold: float,
-    exact_only: bool
-) -> bool:
-    """Check if any output parameter can satisfy any input parameter."""
-    if not outputs or not inputs:
-        return False
-    
-    for out_param in outputs:
-        for in_param in inputs:
-            # Check exact match
-            if _exact_match(out_param, in_param):
-                return True
-            # Check semantic match if not in exact_only mode
-            if not exact_only and _semantic_match(out_param, in_param, semantic_threshold):
-                return True
-    return False
-
-
-def generate_dependency_graph(workflow_path: str) -> str:
-    """
-    Build the parameter dependency graph and persist as JSON in command_dependency_graph.json.
-
-    Returns the path to the generated JSON file.
-    """
-    # Use default values
-    semantic_threshold = 0.85
-    exact_only = False
-    params_by_command = _collect_command_params(workflow_path)
-    routing = RoutingDefinition.build(workflow_path)
-
-    # Exclude core commands and wildcard
-    excluded_commands = {
-        "IntentDetection/go_up",
-        "IntentDetection/reset_context", 
-        "IntentDetection/what_can_i_do",
-        "IntentDetection/what_is_current_context",
-        "wildcard"
-    }
-    
-    # Filter out excluded commands
-    filtered_params = {k: v for k, v in params_by_command.items() if k not in excluded_commands}
-    
-    nodes = sorted(list(filtered_params.keys()))
-    edges: List[Dict[str, Any]] = []
-
-    # Process pairs only once, checking both directions efficiently
-    for i, cmd_x in enumerate(nodes):
-        for cmd_y in nodes[i+1:]:  # Only check each pair once
-            if not _contexts_overlap(routing, cmd_x, cmd_y):
-                continue
-
-            # Print on-going progress status since this is a long-running operation
-            print(f"Checking {cmd_x} <-> {cmd_y}")
-
-            x_params = filtered_params[cmd_x]
-            y_params = filtered_params[cmd_y]
-            
-            # Check both directions efficiently using helper function
-            x_to_y_match = _check_param_dependencies(
-                x_params.outputs, y_params.inputs, semantic_threshold, exact_only
-            )
-            y_to_x_match = _check_param_dependencies(
-                y_params.outputs, x_params.inputs, semantic_threshold, exact_only
-            )
-            
-            # Add edges for matches found
-            if x_to_y_match:
-                edges.append({"from": cmd_y, "to": cmd_x})
-            if y_to_x_match:
-                edges.append({"from": cmd_x, "to": cmd_y})
-            
-            # If no exact/semantic match found, try LLM (which also checks both directions)
-            # if not x_to_y_match and not y_to_x_match and not exact_only:
-            #     llm_direction = _llm_command_dependency(cmd_x, x_params, cmd_y, y_params)
-            #     if llm_direction == "x_to_y":
-            #         edges.append({"from": cmd_y, "to": cmd_x})
-            #     elif llm_direction == "y_to_x":
-            #         edges.append({"from": cmd_x, "to": cmd_y})
-
-    out_path = os.path.join(workflow_path, "command_dependency_graph.json")
-    with open(out_path, "w", encoding="utf-8") as f:
-        json.dump({"nodes": nodes, "edges": edges}, f, indent=2)
-
-    return out_path
-
-
-def _load_graph(graph_path: str) -> Dict[str, Any]:
-    try:
-        with open(graph_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except Exception:
-        return {"nodes": [], "edges": []}
-
-
-def get_dependency_suggestions(
-    graph_path: str,
-    y_qualified_name: str,
-    missing_input_param: str,
-    max_depth: int = 3,
-) -> List[Dict[str, Any]]:
-    """
-    Recursively resolves dependencies, returning a list of plans for resolving the missing param.
-    Note: The simplified graph no longer tracks which specific params match, so this function
-    returns all possible dependency paths without filtering by parameter.
-    """
-    graph = _load_graph(graph_path)
-    edges = graph.get("edges", [])
-
-    # Build adjacency: from -> list of to nodes
-    adj: Dict[str, List[str]] = {}
-    for e in edges:
-        adj.setdefault(e["from"], []).append(e["to"])
-
-    def recurse(node: str, depth: int) -> List[Dict[str, Any]]:
-        if depth > max_depth:
-            return []
-        plans: List[Dict[str, Any]] = []
-        for neighbor in adj.get(node, []):
-            sub_plans = recurse(neighbor, depth + 1)
-            plans.append({
-                "command": neighbor,
-                "sub_plans": sub_plans,
-            })
-        return plans
-
-    dependency_plans = recurse(y_qualified_name, 0)
-    # Prefer shallower trees
-    dependency_plans.sort(key=lambda p: len(p.get("sub_plans", [])))
-    return dependency_plans