fluxloop-cli 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli/__init__.py

@@ -2,7 +2,7 @@
 FluxLoop CLI - Command-line interface for running agent simulations.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 from .main import app
 

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli/config_loader.py

@@ -22,7 +22,7 @@ from .constants import CONFIG_DIRECTORY_NAME
 # Add shared schemas to path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent / "shared"))
 
-from fluxloop.schemas import ExperimentConfig
+from fluxloop.schemas import ExperimentConfig, VariationStrategy
 
 
 def load_experiment_config(
@@ -75,6 +75,8 @@ def load_experiment_config(
         data = merged
         source_dir = project_root
 
+    _normalize_variation_strategies(data)
+
     # Validate and create config object
     try:
         config = ExperimentConfig(**data)
@@ -222,6 +224,66 @@ def _deep_merge(target: Dict[str, Any], incoming: Dict[str, Any]) -> Dict[str, A
     return target
 
 
+def _normalize_variation_strategies(payload: Dict[str, Any]) -> None:
+    """Ensure variation strategies are represented as enum-compatible strings."""
+
+    strategies = payload.get("variation_strategies")
+    if not isinstance(strategies, list):
+        return
+
+    normalized = []
+    for entry in strategies:
+        if isinstance(entry, VariationStrategy):
+            normalized.append(entry.value)
+            continue
+
+        candidate: Optional[str]
+        if isinstance(entry, str):
+            candidate = entry
+        elif isinstance(entry, dict):
+            candidate = (
+                entry.get("type")
+                or entry.get("name")
+                or entry.get("strategy")
+                or entry.get("value")
+            )
+        else:
+            candidate = str(entry)
+
+        if not candidate:
+            continue
+
+        canonical = (
+            candidate.strip()
+            .lower()
+            .replace(" ", "_")
+            .replace("-", "_")
+        )
+
+        alias_map = {
+            "error_prone": (
+                VariationStrategy.ERROR_PRONE.value
+                if hasattr(VariationStrategy, "ERROR_PRONE")
+                else VariationStrategy.TYPO.value
+            ),
+        }
+
+        canonical = alias_map.get(canonical, canonical)
+
+        normalized.append(canonical)
+
+    # Remove duplicates while preserving order
+    seen = set()
+    deduped = []
+    for item in normalized:
+        if item in seen:
+            continue
+        seen.add(item)
+        deduped.append(item)
+
+    payload["variation_strategies"] = deduped
+
+
 def _detect_config_context(resolved_path: Path) -> tuple[str, Path, Path]:
     """Determine whether the path points to legacy or multi-section config."""
 

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli/input_generator.py

@@ -88,40 +88,27 @@ class GenerationError(Exception):
 def generate_inputs(
     config: ExperimentConfig,
     settings: GenerationSettings,
-    recording_template: Optional[Dict[str, Any]] = None,
 ) -> GenerationResult:
     """Generate deterministic input entries based on configuration."""
     base_inputs = config.base_inputs
-    config_for_generation = config
-    if recording_template:
-        base_inputs = [
-            {
-                "input": recording_template["base_content"],
-                "metadata": {
-                    "source": "recording",
-                    "target": recording_template.get("target"),
-                },
-            }
-        ]
-        config_for_generation = config.model_copy(update={"base_inputs": base_inputs})
 
     if not base_inputs:
         raise GenerationError("base_inputs must be defined to generate inputs")
 
-    mode = settings.mode or config_for_generation.input_generation.mode
+    mode = settings.mode or config.input_generation.mode
 
     if mode == InputGenerationMode.LLM:
         strategies: Sequence[VariationStrategy]
         if settings.strategies and len(settings.strategies) > 0:
             strategies = list(settings.strategies)
-        elif config_for_generation.variation_strategies:
-            strategies = config_for_generation.variation_strategies
+        elif config.variation_strategies:
+            strategies = config.variation_strategies
         else:
             strategies = DEFAULT_STRATEGIES
 
         try:
             raw_entries = generate_llm_inputs(
-                config=config_for_generation,
+                config=config,
                 strategies=strategies,
                 settings=settings,
             )
@@ -134,23 +121,16 @@ def generate_inputs(
         ]
 
         metadata = {
-            "config_name": config_for_generation.name,
+            "config_name": config.name,
             "total_base_inputs": len(base_inputs),
-            "total_personas": len(config_for_generation.personas),
+            "total_personas": len(config.personas),
             "strategies": [strategy.value for strategy in strategies],
             "limit": settings.limit,
             "generation_mode": InputGenerationMode.LLM.value,
-            "llm_provider": config_for_generation.input_generation.llm.provider,
-            "llm_model": config_for_generation.input_generation.llm.model,
+            "llm_provider": config.input_generation.llm.provider,
+            "llm_model": config.input_generation.llm.model,
         }
 
-        if recording_template:
-            for entry in entries:
-                entry.metadata["args_template"] = "use_recorded"
-                entry.metadata["template_kwargs"] = recording_template.get("full_kwargs")
-            metadata["recording_target"] = recording_template.get("target")
-            metadata["recording_base_input"] = recording_template.get("base_content")
-
         return GenerationResult(entries=entries, metadata=metadata)
 
     raise GenerationError(

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli/templates.py

@@ -69,9 +69,9 @@ def create_input_config() -> str:
             expected_intent: demo
 
         variation_strategies:
-          - type: rephrase
-          - type: verbose
-          - type: error_prone
+          - rephrase
+          - verbose
+          - error_prone
 
         variation_count: 2
         variation_temperature: 0.7

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli/validators.py

@@ -13,11 +13,21 @@ def parse_variation_strategies(values: Iterable[str]) -> List[VariationStrategy]
     """Parse CLI-provided variation strategy names."""
 
     strategies: List[VariationStrategy] = []
+    alias_map = {
+        "error_prone": (
+            VariationStrategy.ERROR_PRONE.value
+            if hasattr(VariationStrategy, "ERROR_PRONE")
+            else VariationStrategy.TYPO.value
+        )
+    }
+
     for value in values:
         normalized = value.strip().lower().replace("-", "_")
         if not normalized:
             continue
 
+        normalized = alias_map.get(normalized, normalized)
+
         try:
             strategies.append(VariationStrategy(normalized))
         except ValueError as exc:  # pragma: no cover - exercised via Typer

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/fluxloop_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.1 → fluxloop_cli-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fluxloop-cli"
-version = "0.2.1"
+version = "0.2.3"
 description = "FluxLoop CLI for running agent simulations"
 authors = [
     {name = "FluxLoop Team", email = "team@fluxloop.dev"}