iterate with claude

Author: johnnygreco

src/data_designer/cli/commands/list.py

@@ -53,7 +53,7 @@ def list_command(
         if providers_data or models_data:
             print_info("Configuration loaded successfully")
         else:
-            print_warning("No configuration files found. Run 'data-designer init' to create them.")
+            print_warning("No configuration files found. Run 'data-designer config' to see available commands.")
 
 
 def load_providers(provider_path: Path, as_json: bool) -> dict | None:
@@ -123,7 +123,7 @@ def load_providers(provider_path: Path, as_json: bool) -> dict | None:
     except InvalidFilePathError:
         if not as_json:
             print_warning(f"Provider configuration not found: {provider_path}")
-            print_info("Run 'data-designer init' to create it")
+            print_info("Run 'data-designer config providers' to create it")
             console.print()
         return {"file": str(provider_path), "valid": False, "error": "File not found"} if as_json else None
 
@@ -220,7 +220,7 @@ def load_models(model_path: Path, as_json: bool) -> dict | None:
     except InvalidFilePathError:
         if not as_json:
             print_warning(f"Model configuration not found: {model_path}")
-            print_info("Run 'data-designer init' to create it")
+            print_info("Run 'data-designer config models' to create it")
             console.print()
         return {"file": str(model_path), "valid": False, "error": "File not found"} if as_json else None
 

src/data_designer/cli/commands/models.py

@@ -7,11 +7,15 @@
 
 from data_designer.cli.ui import (
     BACK,
+    confirm_action,
     console,
+    display_config_preview,
     print_error,
     print_header,
     print_info,
+    print_navigation_tip,
     print_success,
+    print_warning,
     prompt_text_input,
     select_with_arrows,
 )
@@ -62,14 +66,62 @@ def models_command(
         raise typer.Exit(1)
 
     print_info(f"Configuration will be saved to: {config_dir}")
-    console.print()
+    print_navigation_tip()
+
+    # Check for existing configuration
+    model_path = get_model_config_path(config_dir)
+    existing_config = None
+    mode = "create"  # "create", "add", or "rewrite"
+
+    if model_path.exists():
+        try:
+            existing_config = load_config_file(model_path)
+        except Exception as e:
+            print_warning(f"Could not load existing configuration: {e}")
+            print_info("Starting with new configuration")
+        else:
+            # Successfully loaded existing config
+            print_info(
+                f"Found existing model configuration with {len(existing_config.get('model_configs', []))} model(s)"
+            )
+            console.print()
+
+            # Show existing configuration
+            display_config_preview(existing_config, "Current Configuration")
+            console.print()
+
+            # Ask what to do
+            action_options = {
+                "add": "Add more models to existing configuration",
+                "rewrite": "Rewrite the entire configuration",
+                "exit": "Exit without making changes",
+            }
+            action = select_with_arrows(
+                action_options,
+                "What would you like to do?",
+                default_key="add",
+                allow_back=False,
+            )
+
+            if action is None or action == "exit":
+                print_info("No changes made to configuration")
+                raise typer.Exit(0)
+            elif action == "add":
+                mode = "add"
+            elif action == "rewrite":
+                mode = "rewrite"
 
     # Run the model configuration wizard
-    model_config = configure_models(available_providers)
+    model_config = configure_models(available_providers, existing_config if mode == "add" else None)
     if model_config is None:
         print_error("Model configuration cancelled")
         raise typer.Exit(1)
 
+    # Check if config actually changed (when adding to existing)
+    if mode == "add" and model_config == existing_config:
+        print_info("No changes made to configuration")
+        raise typer.Exit(0)
+
     # Save configuration
     try:
         ensure_config_dir_exists(config_dir)
@@ -81,59 +133,51 @@ def models_command(
         raise typer.Exit(1)
 
 
-def configure_models(available_providers: list[str]) -> dict | None:
+def configure_models(available_providers: list[str], existing_config: dict | None = None) -> dict | None:
     """Interactive configuration for model configs with back navigation.
 
     Args:
         available_providers: List of available provider names
+        existing_config: Optional existing configuration to add to
 
     Returns:
         Model configuration dictionary, or None if cancelled
     """
     # Step-based state machine for back navigation
-    step = "num_models"
-    num_models = 1
+    step = "model_alias"
     model_configs: list[dict] = []
-    model_idx = 0
 
-    # Storage for model data as we build it
-    current_model: dict = {}
+    # If we have existing config, load the models
+    num_existing = 0
+    if existing_config:
+        model_configs = existing_config.get("model_configs", []).copy()
+        num_existing = len(model_configs)
+        print_info(f"Adding to existing {num_existing} model(s)")
+        console.print()
 
-    while True:
-        if step == "num_models":
-            # Ask how many models
-            result = prompt_text_input(
-                "How many models do you want to configure? (1-10)",
-                default="1",
-                validator=lambda x: validate_positive_int(x) if x else (True, None),
-                allow_back=False,  # First step, can't go back
-            )
+    # Track how many NEW models we've added (for numbering and back navigation)
+    new_models_count = 0
 
-            if result is None:
-                return None
+    # Storage for model data as we build it
+    current_model: dict = {}
 
-            num_models = int(result) if result else 1
-            num_models = min(max(num_models, 1), 10)  # Clamp to 1-10
-            model_idx = 0
-            model_configs = []
-            step = "model_alias"
-
-        elif step == "model_alias":
-            if model_idx >= num_models:
-                # Done with all models
-                step = "done"
-                continue
+    # History stack for proper back navigation
+    # Each entry: (step_name, model_data)
+    history: list[tuple[str, dict]] = []
 
+    while True:
+        if step == "model_alias":
             console.print()
-            print_info(f"Configuring model {model_idx + 1}/{num_models}")
+            total_count = num_existing + new_models_count + 1
+            print_info(f"Configuring model {total_count}")
 
             # Get existing model aliases for validation
             model_aliases = {m["alias"] for m in model_configs}
 
             # Model alias
             result = prompt_text_input(
                 "Model alias (used in your configs)",
-                default="llama-3-70b" if model_idx == 0 else current_model.get("alias"),
+                default="llama-3-70b" if new_models_count == 0 and num_existing == 0 else current_model.get("alias"),
                 validator=lambda x, aliases=model_aliases: (
                     (False, "Model alias must not be empty")
                     if not x
@@ -147,26 +191,40 @@ def configure_models(available_providers: list[str]) -> dict | None:
             if result is None:
                 return None
             elif result is BACK:
-                # Go back to previous model or num_models
-                if model_idx > 0 and len(model_configs) > 0:
-                    # Go back to previous model
-                    model_idx -= 1
-                    current_model = model_configs.pop()
-                    step = "model_max_tokens"  # Go to last step of previous model
+                # Go back using history if available
+                if history:
+                    # Pop from history and restore state to edit a completed model
+                    prev_step, prev_model = history.pop()
+                    # Remove the last model from the list so we can re-add it after editing
+                    if len(model_configs) > num_existing:
+                        model_configs.pop()
+                        new_models_count -= 1
+                    current_model = prev_model
+                    step = prev_step
                     continue
                 else:
-                    # First model, go back to num_models question
-                    step = "num_models"
-                    continue
+                    # No history - check if there are existing models
+                    if num_existing > 0:
+                        # There are existing models, so canceling is OK
+                        if confirm_action("Discard the new models?", default=False):
+                            return existing_config  # Return the original config unchanged
+                        continue
+                    else:
+                        # No existing models, confirm complete cancellation
+                        if confirm_action("Cancel all model configuration?", default=False):
+                            return None
+                        continue
 
             current_model = {"alias": result}
             step = "model_id"
 
         elif step == "model_id":
             # Model ID
             result = prompt_text_input(
-                "Model ID (e.g., meta/llama-3.3-70b-instruct)",
-                default="meta/llama-3.3-70b-instruct" if model_idx == 0 else current_model.get("model"),
+                "Model ID",
+                default="meta/llama-3.3-70b-instruct"
+                if new_models_count == 0 and num_existing == 0
+                else current_model.get("model"),
                 validator=lambda x: (False, "Model ID is required") if not x else (True, None),
                 allow_back=True,
             )
@@ -216,7 +274,7 @@ def configure_models(available_providers: list[str]) -> dict | None:
             print_info("Inference Parameters")
 
             result = prompt_text_input(
-                f"Temperature ({MIN_TEMPERATURE}-{MAX_TEMPERATURE})",
+                f"Temperature <dim>({MIN_TEMPERATURE}-{MAX_TEMPERATURE})</dim>",
                 default="0.7",
                 validator=lambda x: validate_numeric_range(x, MIN_TEMPERATURE, MAX_TEMPERATURE) if x else (True, None),
                 allow_back=True,
@@ -235,7 +293,7 @@ def configure_models(available_providers: list[str]) -> dict | None:
         elif step == "model_top_p":
             # Top P
             result = prompt_text_input(
-                f"Top P ({MIN_TOP_P}-{MAX_TOP_P})",
+                f"Top P <dim>({MIN_TOP_P}-{MAX_TOP_P})</dim>",
                 default="0.9",
                 validator=lambda x: validate_numeric_range(x, MIN_TOP_P, MAX_TOP_P) if x else (True, None),
                 allow_back=True,
@@ -254,7 +312,7 @@ def configure_models(available_providers: list[str]) -> dict | None:
         elif step == "model_max_tokens":
             # Max tokens
             result = prompt_text_input(
-                "Max tokens (press Enter for default: 2048)",
+                "Max tokens",
                 default="2048",
                 validator=lambda x: validate_positive_int(x) if x else (True, None),
                 allow_back=True,
@@ -274,13 +332,53 @@ def configure_models(available_providers: list[str]) -> dict | None:
             try:
                 ModelConfig.model_validate(current_model)
                 model_configs.append(current_model)
-                model_idx += 1
+                new_models_count += 1
+                # Save to history before moving on
+                history.append(("model_max_tokens", current_model.copy()))
                 current_model = {}
-                step = "model_alias"  # Move to next model or finish
+                step = "add_another"  # Ask if they want to add another model
             except Exception as e:
                 print_error(f"Invalid model configuration: {e}")
                 return None
 
+        elif step == "add_another":
+            # Ask if user wants to add another model
+            console.print()
+
+            # Create options for selection with back support
+            add_another_options = {
+                "yes": "Add another model",
+                "no": "Finish configuring models",
+            }
+            result = select_with_arrows(
+                add_another_options,
+                "Would you like to add another model?",
+                default_key="no",
+                allow_back=True,
+            )
+
+            if result is None:
+                return None
+            elif result is BACK:
+                # Go back to the last model's max_tokens step
+                if history:
+                    prev_step, prev_model = history.pop()
+                    # Remove the last model so we can re-add it after editing
+                    if len(model_configs) > num_existing:
+                        model_configs.pop()
+                        new_models_count -= 1
+                    current_model = prev_model
+                    step = "model_max_tokens"
+                continue
+            elif result == "yes":
+                step = "model_alias"
+            else:  # "no"
+                step = "done"
+
         elif step == "done":
+            if len(model_configs) == 0:
+                print_error("No models configured")
+                return None
+
             config = {"model_configs": model_configs}
             return config