massgen 0.1.0a2__py3-none-any.whl → 0.1.1__py3-none-any.whl

massgen/config_builder.py

@@ -25,7 +25,11 @@ from rich.prompt import Confirm, Prompt
 from rich.table import Table
 from rich.theme import Theme
 
-from massgen.backend.capabilities import BACKEND_CAPABILITIES, get_capabilities
+from massgen.backend.capabilities import (
+    BACKEND_CAPABILITIES,
+    get_capabilities,
+    has_capability,
+)
 
 # Load environment variables
 load_dotenv()
@@ -33,11 +37,11 @@ load_dotenv()
 # Custom theme for the CLI - using colors that work on both light and dark backgrounds
 custom_theme = Theme(
     {
-        "info": "bright_blue",
-        "warning": "bright_yellow",
-        "error": "bright_red bold",
-        "success": "bright_green bold",
-        "prompt": "bright_magenta bold",
+        "info": "#4A90E2",  # Medium blue - matches system status colors
+        "warning": "#CC6600",  # Orange-brown - works on both light and dark
+        "error": "#CC0000 bold",  # Deep red - strong contrast
+        "success": "#00AA44 bold",  # Deep green - visible on both
+        "prompt": "#6633CC bold",  # Purple - good on both backgrounds
     },
 )
 
@@ -790,12 +794,13 @@ class ConfigBuilder:
             console.print(f"[error]❌ Error configuring custom MCP: {e}[/error]")
             return None
 
-    def batch_create_agents(self, count: int, provider_id: str) -> List[Dict]:
+    def batch_create_agents(self, count: int, provider_id: str, start_index: int = 0) -> List[Dict]:
         """Create multiple agents with the same provider.
 
         Args:
             count: Number of agents to create
             provider_id: Provider ID (e.g., 'openai', 'claude')
+            start_index: Starting index for agent naming (default: 0)
 
         Returns:
             List of agent configurations with default models
@@ -806,7 +811,7 @@ class ConfigBuilder:
         # Generate agent IDs like agent_a, agent_b, agent_c...
         for i in range(count):
             # Convert index to letter (0->a, 1->b, 2->c, etc.)
-            agent_letter = chr(ord("a") + i)
+            agent_letter = chr(ord("a") + start_index + i)
 
             agent = {
                 "id": f"agent_{agent_letter}",
@@ -816,20 +821,21 @@ class ConfigBuilder:
                 },
             }
 
-            # Add workspace for Claude Code (use numbers, not letters)
+            # Add workspace for Claude Code (use global index for unique workspace names)
             if provider_info.get("type") == "claude_code":
-                agent["backend"]["cwd"] = f"workspace{i + 1}"
+                agent["backend"]["cwd"] = f"workspace{start_index + i + 1}"
 
             agents.append(agent)
 
         return agents
 
-    def clone_agent(self, source_agent: Dict, new_id: str) -> Dict:
-        """Clone an agent's configuration with a new ID.
+    def clone_agent(self, source_agent: Dict, new_id: str, target_backend_type: str = None) -> Dict:
+        """Clone an agent's configuration with a new ID, optionally preserving target backend.
 
         Args:
             source_agent: Agent to clone
             new_id: New agent ID
+            target_backend_type: If provided, preserve this backend type instead of copying source's
 
         Returns:
             Cloned agent with updated ID and workspace (if applicable)
@@ -839,9 +845,91 @@ class ConfigBuilder:
         cloned = copy.deepcopy(source_agent)
         cloned["id"] = new_id
 
-        # Update workspace for Claude Code agents to avoid conflicts
-        backend_type = cloned.get("backend", {}).get("type")
-        if backend_type == "claude_code" and "cwd" in cloned.get("backend", {}):
+        # If target backend type is different, preserve it and update model
+        if target_backend_type and target_backend_type != source_agent.get("backend", {}).get("type"):
+            # Find target provider info to get default model
+            target_provider_info = None
+            for pid, pinfo in self.PROVIDERS.items():
+                if pinfo.get("type") == target_backend_type:
+                    target_provider_info = pinfo
+                    break
+
+            if target_provider_info:
+                # Preserve tool enablement flags (provider-agnostic)
+                preserved_settings = {}
+                skipped_settings = []
+                source_backend = source_agent.get("backend", {})
+                source_backend_type = source_backend.get("type")
+
+                # Copy filesystem settings (provider-agnostic)
+                if "cwd" in source_backend:
+                    preserved_settings["cwd"] = source_backend["cwd"]
+
+                # Copy MCP servers (provider-agnostic, but check if target supports MCP)
+                if "mcp_servers" in source_backend:
+                    # Check if target provider supports MCP
+                    target_supports_mcp = "mcp" in target_provider_info.get("supports", [])
+                    if target_supports_mcp:
+                        preserved_settings["mcp_servers"] = copy.deepcopy(source_backend["mcp_servers"])
+                    else:
+                        skipped_settings.append("mcp_servers (not supported by target provider)")
+
+                # Copy tool flags if they exist and are supported by target
+                target_caps = get_capabilities(target_backend_type)
+
+                for key in [
+                    "enable_web_search",
+                    "enable_code_execution",
+                    "enable_code_interpreter",
+                    "enable_mcp_command_line",
+                    "command_line_execution_mode",
+                ]:
+                    if key in source_backend:
+                        # Check if target supports this specific tool
+                        if key == "enable_web_search":
+                            if has_capability(target_backend_type, "web_search"):
+                                preserved_settings[key] = source_backend[key]
+                            else:
+                                skipped_settings.append(f"{key} (not supported by {target_backend_type})")
+                        elif key == "enable_code_interpreter":
+                            # code_interpreter is OpenAI/Azure-specific
+                            if target_caps and "code_interpreter" in target_caps.builtin_tools:
+                                preserved_settings[key] = source_backend[key]
+                            else:
+                                skipped_settings.append(f"{key} (not supported by {target_backend_type})")
+                        elif key == "enable_code_execution":
+                            # code_execution is Claude/Gemini-specific
+                            if target_caps and "code_execution" in target_caps.builtin_tools:
+                                preserved_settings[key] = source_backend[key]
+                            else:
+                                skipped_settings.append(f"{key} (not supported by {target_backend_type})")
+                        else:
+                            # MCP command line and execution mode are universal
+                            preserved_settings[key] = source_backend[key]
+
+                # Copy reasoning/text settings if target is OpenAI
+                if target_backend_type == "openai":
+                    for key in ["text", "reasoning"]:
+                        if key in source_backend:
+                            preserved_settings[key] = copy.deepcopy(source_backend[key])
+                elif source_backend_type == "openai":
+                    # Source was OpenAI but target is not - these settings can't be copied
+                    for key in ["text", "reasoning"]:
+                        if key in source_backend:
+                            skipped_settings.append(f"{key} (OpenAI-specific)")
+
+                # Replace backend with target provider's default model + preserved settings
+                cloned["backend"] = {
+                    "type": target_backend_type,
+                    "model": target_provider_info.get("models", ["default"])[0],
+                    **preserved_settings,
+                }
+
+                # Store skipped settings for later warning
+                cloned["_skipped_settings"] = skipped_settings
+
+        # Update workspace for filesystem-enabled agents to avoid conflicts
+        if "cwd" in cloned.get("backend", {}):
             # Extract number from new_id (e.g., "agent_b" -> 2)
             if "_" in new_id and len(new_id) > 0:
                 agent_letter = new_id.split("_")[-1]
@@ -1049,12 +1137,13 @@ class ConfigBuilder:
             console.print(f"[error]❌ Error modifying agent: {e}[/error]")
             return agent
 
-    def apply_preset_to_agent(self, agent: Dict, use_case: str) -> Dict:
+    def apply_preset_to_agent(self, agent: Dict, use_case: str, agent_index: int = 1) -> Dict:
         """Auto-apply preset configuration to an agent.
 
         Args:
             agent: Agent configuration dict
             use_case: Use case ID for preset configuration
+            agent_index: Agent index for unique workspace naming (1-based)
 
         Returns:
             Updated agent configuration with preset applied
@@ -1080,7 +1169,8 @@ class ConfigBuilder:
         # Auto-enable filesystem if recommended
         if "filesystem" in recommended_tools and "filesystem" in provider_info.get("supports", []):
             if not agent["backend"].get("cwd"):
-                agent["backend"]["cwd"] = "workspace"
+                # Generate unique workspace name for each agent
+                agent["backend"]["cwd"] = f"workspace{agent_index}"
 
         # Auto-enable web search if recommended
         if "web_search" in recommended_tools:
@@ -1673,7 +1763,7 @@ class ConfigBuilder:
                             if not provider_id:
                                 provider_id = available_providers[0]
 
-                            agent_batch = self.batch_create_agents(1, provider_id)
+                            agent_batch = self.batch_create_agents(1, provider_id, len(agents))
                             agents.extend(agent_batch)
 
                             provider_name = self.PROVIDERS.get(provider_id, {}).get("name", provider_id)
@@ -1843,7 +1933,7 @@ class ConfigBuilder:
                 console.print()
                 console.print("  [cyan]Applying preset configuration to all agents...[/cyan]")
                 for i, agent in enumerate(agents):
-                    agents[i] = self.apply_preset_to_agent(agent, use_case)
+                    agents[i] = self.apply_preset_to_agent(agent, use_case, agent_index=i + 1)
 
                 console.print(f"  [green]✅ {len(agents)} agent(s) configured with preset[/green]")
                 console.print()
@@ -1878,17 +1968,107 @@ class ConfigBuilder:
                             ).ask()
 
                             if clone_choice == "clone":
-                                # Clone the previous agent
+                                # Clone the previous agent, preserving current agent's backend type
                                 source_agent = agents[i - 2]
-                                agent = self.clone_agent(source_agent, agent["id"])
+                                target_backend_type = agent.get("backend", {}).get("type")
+                                source_backend_type = source_agent.get("backend", {}).get("type")
+
+                                agent = self.clone_agent(source_agent, agent["id"], target_backend_type)
+
+                                # If cross-provider cloning, prompt for model selection
+                                if target_backend_type != source_backend_type:
+                                    console.print(f"✅ Cloned settings from agent_{chr(ord('a') + i - 2)} ({source_backend_type})")
+                                    console.print(f"   [dim]Note: Model must be selected for {target_backend_type}[/dim]")
+
+                                    # Show skipped settings warning if any
+                                    skipped = agent.get("_skipped_settings", [])
+                                    if skipped:
+                                        console.print("   [yellow]⚠️  Skipped incompatible settings:[/yellow]")
+                                        for setting in skipped:
+                                            console.print(f"      • {setting}")
+                                    console.print()
+
+                                    # Prompt for model selection
+                                    target_provider_info = None
+                                    for _, pinfo in self.PROVIDERS.items():
+                                        if pinfo.get("type") == target_backend_type:
+                                            target_provider_info = pinfo
+                                            break
+
+                                    if target_provider_info and target_provider_info.get("models"):
+                                        model_choice = questionary.select(
+                                            f"Select {target_backend_type} model:",
+                                            choices=target_provider_info["models"],
+                                            style=questionary.Style(
+                                                [
+                                                    ("selected", "fg:cyan bold"),
+                                                    ("pointer", "fg:cyan bold"),
+                                                ],
+                                            ),
+                                        ).ask()
+
+                                        if model_choice:
+                                            agent["backend"]["model"] = model_choice
+                                            console.print(f"   ✅ Model: {model_choice}")
+
+                                    # Clean up temporary skipped settings marker
+                                    agent.pop("_skipped_settings", None)
+                                else:
+                                    console.print(f"✅ Cloned configuration from agent_{chr(ord('a') + i - 2)}")
+                                    # Clean up temporary skipped settings marker
+                                    agent.pop("_skipped_settings", None)
+
                                 agents[i - 1] = agent
-                                console.print(f"✅ Cloned configuration from agent_{chr(ord('a') + i - 2)}")
                                 console.print()
                                 continue
                             elif clone_choice == "clone_modify":
-                                # Clone and selectively modify
+                                # Clone and selectively modify, preserving current agent's backend type
                                 source_agent = agents[i - 2]
-                                agent = self.clone_agent(source_agent, agent["id"])
+                                target_backend_type = agent.get("backend", {}).get("type")
+                                source_backend_type = source_agent.get("backend", {}).get("type")
+
+                                agent = self.clone_agent(source_agent, agent["id"], target_backend_type)
+
+                                # If cross-provider cloning, prompt for model selection before modification
+                                if target_backend_type != source_backend_type:
+                                    console.print(f"✅ Cloned settings from agent_{chr(ord('a') + i - 2)} ({source_backend_type})")
+                                    console.print(f"   [dim]Note: Model must be selected for {target_backend_type}[/dim]")
+
+                                    # Show skipped settings warning if any
+                                    skipped = agent.get("_skipped_settings", [])
+                                    if skipped:
+                                        console.print("   [yellow]⚠️  Skipped incompatible settings:[/yellow]")
+                                        for setting in skipped:
+                                            console.print(f"      • {setting}")
+                                    console.print()
+
+                                    # Prompt for model selection
+                                    target_provider_info = None
+                                    for _, pinfo in self.PROVIDERS.items():
+                                        if pinfo.get("type") == target_backend_type:
+                                            target_provider_info = pinfo
+                                            break
+
+                                    if target_provider_info and target_provider_info.get("models"):
+                                        model_choice = questionary.select(
+                                            f"Select {target_backend_type} model:",
+                                            choices=target_provider_info["models"],
+                                            style=questionary.Style(
+                                                [
+                                                    ("selected", "fg:cyan bold"),
+                                                    ("pointer", "fg:cyan bold"),
+                                                ],
+                                            ),
+                                        ).ask()
+
+                                        if model_choice:
+                                            agent["backend"]["model"] = model_choice
+                                            console.print(f"   ✅ Model: {model_choice}")
+                                            console.print()
+
+                                    # Clean up temporary skipped settings marker before modification
+                                    agent.pop("_skipped_settings", None)
+
                                 agent = self.modify_cloned_agent(agent, i)
                                 agents[i - 1] = agent
                                 continue
@@ -1922,17 +2102,107 @@ class ConfigBuilder:
                         ).ask()
 
                         if clone_choice == "clone":
-                            # Clone the previous agent
+                            # Clone the previous agent, preserving current agent's backend type
                             source_agent = agents[i - 2]
-                            agent = self.clone_agent(source_agent, agent["id"])
+                            target_backend_type = agent.get("backend", {}).get("type")
+                            source_backend_type = source_agent.get("backend", {}).get("type")
+
+                            agent = self.clone_agent(source_agent, agent["id"], target_backend_type)
+
+                            # If cross-provider cloning, prompt for model selection
+                            if target_backend_type != source_backend_type:
+                                console.print(f"✅ Cloned settings from agent_{chr(ord('a') + i - 2)} ({source_backend_type})")
+                                console.print(f"   [dim]Note: Model must be selected for {target_backend_type}[/dim]")
+
+                                # Show skipped settings warning if any
+                                skipped = agent.get("_skipped_settings", [])
+                                if skipped:
+                                    console.print("   [yellow]⚠️  Skipped incompatible settings:[/yellow]")
+                                    for setting in skipped:
+                                        console.print(f"      • {setting}")
+                                console.print()
+
+                                # Prompt for model selection
+                                target_provider_info = None
+                                for _, pinfo in self.PROVIDERS.items():
+                                    if pinfo.get("type") == target_backend_type:
+                                        target_provider_info = pinfo
+                                        break
+
+                                if target_provider_info and target_provider_info.get("models"):
+                                    model_choice = questionary.select(
+                                        f"Select {target_backend_type} model:",
+                                        choices=target_provider_info["models"],
+                                        style=questionary.Style(
+                                            [
+                                                ("selected", "fg:cyan bold"),
+                                                ("pointer", "fg:cyan bold"),
+                                            ],
+                                        ),
+                                    ).ask()
+
+                                    if model_choice:
+                                        agent["backend"]["model"] = model_choice
+                                        console.print(f"   ✅ Model: {model_choice}")
+
+                                # Clean up temporary skipped settings marker
+                                agent.pop("_skipped_settings", None)
+                            else:
+                                console.print(f"✅ Cloned configuration from agent_{chr(ord('a') + i - 2)}")
+                                # Clean up temporary skipped settings marker
+                                agent.pop("_skipped_settings", None)
+
                             agents[i - 1] = agent
-                            console.print(f"✅ Cloned configuration from agent_{chr(ord('a') + i - 2)}")
                             console.print()
                             continue
                         elif clone_choice == "clone_modify":
-                            # Clone and selectively modify
+                            # Clone and selectively modify, preserving current agent's backend type
                             source_agent = agents[i - 2]
-                            agent = self.clone_agent(source_agent, agent["id"])
+                            target_backend_type = agent.get("backend", {}).get("type")
+                            source_backend_type = source_agent.get("backend", {}).get("type")
+
+                            agent = self.clone_agent(source_agent, agent["id"], target_backend_type)
+
+                            # If cross-provider cloning, prompt for model selection before modification
+                            if target_backend_type != source_backend_type:
+                                console.print(f"✅ Cloned settings from agent_{chr(ord('a') + i - 2)} ({source_backend_type})")
+                                console.print(f"   [dim]Note: Model must be selected for {target_backend_type}[/dim]")
+
+                                # Show skipped settings warning if any
+                                skipped = agent.get("_skipped_settings", [])
+                                if skipped:
+                                    console.print("   [yellow]⚠️  Skipped incompatible settings:[/yellow]")
+                                    for setting in skipped:
+                                        console.print(f"      • {setting}")
+                                console.print()
+
+                                # Prompt for model selection
+                                target_provider_info = None
+                                for _, pinfo in self.PROVIDERS.items():
+                                    if pinfo.get("type") == target_backend_type:
+                                        target_provider_info = pinfo
+                                        break
+
+                                if target_provider_info and target_provider_info.get("models"):
+                                    model_choice = questionary.select(
+                                        f"Select {target_backend_type} model:",
+                                        choices=target_provider_info["models"],
+                                        style=questionary.Style(
+                                            [
+                                                ("selected", "fg:cyan bold"),
+                                                ("pointer", "fg:cyan bold"),
+                                            ],
+                                        ),
+                                    ).ask()
+
+                                    if model_choice:
+                                        agent["backend"]["model"] = model_choice
+                                        console.print(f"   ✅ Model: {model_choice}")
+                                        console.print()
+
+                                # Clean up temporary skipped settings marker before modification
+                                agent.pop("_skipped_settings", None)
+
                             agent = self.modify_cloned_agent(agent, i)
                             agents[i - 1] = agent
                             continue
@@ -2051,6 +2321,80 @@ class ConfigBuilder:
                     console.print()
                     console.print("  ✅ Planning mode enabled - MCP tools will plan without executing during coordination")
 
+            # Voting Sensitivity - only ask for multi-agent setups
+            if len(agents) > 1:
+                console.print()
+                console.print("  [dim]Voting Sensitivity: Controls how agents reach consensus[/dim]")
+                console.print("  [dim]• L: Lenient - Lower threshold for faster decisions (default)[/dim]")
+                console.print("  [dim]• B: Balanced - Often requires more answers for consensus[/dim]")
+                console.print("  [dim]• S: Strict - High standards, maximum quality (slowest)[/dim]")
+                console.print()
+
+                voting_input = Prompt.ask(
+                    "  [prompt]Voting sensitivity[/prompt]",
+                    choices=["l", "b", "s"],
+                    default="l",
+                )
+
+                # Map input to full value
+                voting_map = {"l": "lenient", "b": "balanced", "s": "strict"}
+                voting_choice = voting_map[voting_input]
+
+                orchestrator_config["voting_sensitivity"] = voting_choice
+                console.print()
+                console.print(f"  ✅ Voting sensitivity set to: {voting_choice}")
+
+                # Answer Count Limit
+                console.print()
+                console.print("  [dim]Answer Count Limit: Controls maximum new answers per agent[/dim]")
+                console.print("  [dim]• Prevents endless coordination rounds[/dim]")
+                console.print("  [dim]• After limit, agents can only vote (not provide new answers)[/dim]")
+                console.print()
+
+                limit_input = Prompt.ask(
+                    "  [prompt]Max new answers per agent (leave empty for unlimited)[/prompt]",
+                    default="",
+                )
+
+                if limit_input.strip():
+                    try:
+                        answer_limit = int(limit_input)
+                        if answer_limit > 0:
+                            orchestrator_config["max_new_answers_per_agent"] = answer_limit
+                            console.print()
+                            console.print(f"  ✅ Answer limit set to: {answer_limit} per agent")
+                        else:
+                            console.print()
+                            console.print("  ⚠️  Invalid limit - using unlimited")
+                    except ValueError:
+                        console.print()
+                        console.print("  ⚠️  Invalid number - using unlimited")
+                else:
+                    console.print()
+                    console.print("  ✅ Answer limit: unlimited")
+
+                # Answer Novelty Requirement
+                console.print()
+                console.print("  [dim]Answer Novelty: Controls how different new answers must be[/dim]")
+                console.print("  [dim]• L: Lenient - No similarity checks (default, fastest)[/dim]")
+                console.print("  [dim]• B: Balanced - Reject if >70% overlap (prevents rephrasing)[/dim]")
+                console.print("  [dim]• S: Strict - Reject if >50% overlap (requires new approaches)[/dim]")
+                console.print()
+
+                novelty_input = Prompt.ask(
+                    "  [prompt]Answer novelty requirement[/prompt]",
+                    choices=["l", "b", "s"],
+                    default="l",
+                )
+
+                # Map input to full value
+                novelty_map = {"l": "lenient", "b": "balanced", "s": "strict"}
+                novelty_choice = novelty_map[novelty_input]
+
+                orchestrator_config["answer_novelty_requirement"] = novelty_choice
+                console.print()
+                console.print(f"  ✅ Answer novelty requirement set to: {novelty_choice}")
+
             return agents, orchestrator_config
 
         except (KeyboardInterrupt, EOFError):
@@ -2135,11 +2479,13 @@ class ConfigBuilder:
                 default="1",
             )
 
+            # Determine save directory
+            save_dir = None
             if save_location == "2":
                 # Save to ~/.config/massgen/agents/
-                agents_dir = Path.home() / ".config/massgen/agents"
-                agents_dir.mkdir(parents=True, exist_ok=True)
-                default_name = str(agents_dir / "my_massgen_config.yaml")
+                save_dir = Path.home() / ".config/massgen/agents"
+                save_dir.mkdir(parents=True, exist_ok=True)
+                default_name = str(save_dir / "my_massgen_config.yaml")
 
             while True:
                 try:
@@ -2157,7 +2503,10 @@ class ConfigBuilder:
                     if not filename.endswith(".yaml"):
                         filename += ".yaml"
 
+                    # Create filepath - if save_dir is set and filename is not absolute, join them
                     filepath = Path(filename)
+                    if save_dir and not filepath.is_absolute():
+                        filepath = save_dir / filepath
 
                     # Check if file exists
                     if filepath.exists():