from __future__ import annotations import argparse import json import os from typing import Any, Dict, List, Optional from deck_builder.builder import DeckBuilder from deck_builder import builder_constants as bc from file_setup.setup import initial_setup from tagging import tagger def _is_stale(file1: str, file2: str) -> bool: """Return True if file2 is missing or older than file1.""" if not os.path.isfile(file2): return True if not os.path.isfile(file1): return True return os.path.getmtime(file2) < os.path.getmtime(file1) def _ensure_data_ready(): cards_csv = os.path.join("csv_files", "cards.csv") tagging_json = os.path.join("csv_files", ".tagging_complete.json") # If cards.csv is missing, run full setup+tagging if not os.path.isfile(cards_csv): print("cards.csv not found, running full setup and tagging...") initial_setup() tagger.run_tagging() _write_tagging_flag(tagging_json) # If tagging_complete is missing or stale, run tagging elif not os.path.isfile(tagging_json) or _is_stale(cards_csv, tagging_json): print(".tagging_complete.json missing or stale, running tagging...") tagger.run_tagging() _write_tagging_flag(tagging_json) def _write_tagging_flag(tagging_json): import json from datetime import datetime os.makedirs(os.path.dirname(tagging_json), exist_ok=True) with open(tagging_json, 'w', encoding='utf-8') as f: json.dump({'tagged_at': datetime.now().isoformat(timespec='seconds')}, f) def run( command_name: str = "", add_creatures: bool = True, add_non_creature_spells: bool = True, add_ramp: bool = True, add_removal: bool = True, add_wipes: bool = True, add_card_advantage: bool = True, add_protection: bool = True, primary_choice: int = 1, secondary_choice: Optional[int] = None, tertiary_choice: Optional[int] = None, add_lands: bool = True, fetch_count: Optional[int] = 3, dual_count: Optional[int] = None, triple_count: Optional[int] = None, utility_count: Optional[int] = None, ideal_counts: Optional[Dict[str, int]] = None, bracket_level: Optional[int] = None, # Include/Exclude configuration (M1: Config + Validation + Persistence) include_cards: Optional[List[str]] = None, exclude_cards: Optional[List[str]] = None, enforcement_mode: str = "warn", allow_illegal: bool = False, fuzzy_matching: bool = True, ) -> DeckBuilder: """Run a scripted non-interactive deck build and return the DeckBuilder instance.""" scripted_inputs: List[str] = [] # Commander query & selection scripted_inputs.append(command_name) # initial query scripted_inputs.append("1") # choose first search match to inspect scripted_inputs.append("y") # confirm commander # Primary tag selection scripted_inputs.append(str(primary_choice)) # Secondary tag selection or stop (0) if secondary_choice is not None: scripted_inputs.append(str(secondary_choice)) # Tertiary tag selection or stop (0) if tertiary_choice is not None: scripted_inputs.append(str(tertiary_choice)) else: scripted_inputs.append("0") else: scripted_inputs.append("0") # stop at primary # Bracket (meta power / style) selection; default to 3 if not provided scripted_inputs.append(str(bracket_level if isinstance(bracket_level, int) and 1 <= bracket_level <= 5 else 3)) # Ideal count prompts (press Enter for defaults). Include fetch_lands if present. ideal_keys = { "ramp", "lands", "basic_lands", "fetch_lands", "creatures", "removal", "wipes", "card_advantage", "protection", } for key in bc.DECK_COMPOSITION_PROMPTS.keys(): if key in ideal_keys: scripted_inputs.append("") def scripted_input(prompt: str) -> str: if scripted_inputs: return scripted_inputs.pop(0) # Fallback to auto-accept defaults for any unexpected prompts return "" builder = DeckBuilder(input_func=scripted_input) # Mark this run as headless so builder can adjust exports and logging try: builder.headless = True # type: ignore[attr-defined] except Exception: pass # Configure include/exclude settings (M1: Config + Validation + Persistence) try: builder.include_cards = list(include_cards or []) # type: ignore[attr-defined] builder.exclude_cards = list(exclude_cards or []) # type: ignore[attr-defined] builder.enforcement_mode = enforcement_mode # type: ignore[attr-defined] builder.allow_illegal = allow_illegal # type: ignore[attr-defined] builder.fuzzy_matching = fuzzy_matching # type: ignore[attr-defined] except Exception: pass # If ideal_counts are provided (from JSON), use them as the current defaults # so the step 2 prompts will show these values and our blank entries will accept them. if isinstance(ideal_counts, dict) and ideal_counts: try: ic: Dict[str, int] = {} for k, v in ideal_counts.items(): try: iv = int(v) if v is not None else None # type: ignore except Exception: continue if iv is None: continue # Only accept known keys if k in {"ramp","lands","basic_lands","creatures","removal","wipes","card_advantage","protection"}: ic[k] = iv if ic: builder.ideal_counts.update(ic) # type: ignore[attr-defined] except Exception: pass builder.run_initial_setup() builder.run_deck_build_step1() builder.run_deck_build_step2() # Land sequence (optional) if add_lands: def call(method: str, **kwargs: Any) -> None: fn = getattr(builder, method, None) if callable(fn): try: fn(**kwargs) except Exception: pass for method, kwargs in [ ("run_land_step1", {}), ("run_land_step2", {}), ("run_land_step3", {}), ("run_land_step4", {"requested_count": fetch_count}), ("run_land_step5", {"requested_count": dual_count}), ("run_land_step6", {"requested_count": triple_count}), ("run_land_step7", {"requested_count": utility_count}), ("run_land_step8", {}), ]: call(method, **kwargs) if add_creatures: builder.add_creatures() # Non-creature spell categories (ramp / removal / wipes / draw / protection) did_bulk = False if add_non_creature_spells and hasattr(builder, "add_non_creature_spells"): try: builder.add_non_creature_spells() did_bulk = True except Exception: did_bulk = False if not did_bulk: for method, flag in [ ("add_ramp", add_ramp), ("add_removal", add_removal), ("add_board_wipes", add_wipes), ("add_card_advantage", add_card_advantage), ("add_protection", add_protection), ]: if flag: fn = getattr(builder, method, None) if callable(fn): try: fn() except Exception: pass builder.post_spell_land_adjust() _export_outputs(builder) return builder def _should_export_json_headless() -> bool: return os.getenv('HEADLESS_EXPORT_JSON', '').strip().lower() in {'1','true','yes','on'} def _print_include_exclude_summary(builder: DeckBuilder) -> None: """Print include/exclude summary to console (M4: Extended summary printing).""" if not hasattr(builder, 'include_exclude_diagnostics') or not builder.include_exclude_diagnostics: return diagnostics = builder.include_exclude_diagnostics # Skip if no include/exclude activity if not any([ diagnostics.get('include_cards'), diagnostics.get('exclude_cards'), diagnostics.get('include_added'), diagnostics.get('excluded_removed') ]): return print("\n" + "=" * 50) print("INCLUDE/EXCLUDE SUMMARY") print("=" * 50) # Include cards impact include_cards = diagnostics.get('include_cards', []) if include_cards: print(f"\n✓ Must Include Cards ({len(include_cards)}):") include_added = diagnostics.get('include_added', []) if include_added: print(f" ✓ Successfully Added ({len(include_added)}):") for card in include_added: print(f" • {card}") missing_includes = diagnostics.get('missing_includes', []) if missing_includes: print(f" ⚠ Could Not Include ({len(missing_includes)}):") for card in missing_includes: print(f" • {card}") # Exclude cards impact exclude_cards = diagnostics.get('exclude_cards', []) if exclude_cards: print(f"\n✗ Must Exclude Cards ({len(exclude_cards)}):") excluded_removed = diagnostics.get('excluded_removed', []) if excluded_removed: print(f" ✓ Successfully Excluded ({len(excluded_removed)}):") for card in excluded_removed: print(f" • {card}") print(" Patterns:") for pattern in exclude_cards: print(f" • {pattern}") # Validation issues issues = [] fuzzy_corrections = diagnostics.get('fuzzy_corrections', {}) if fuzzy_corrections: issues.append(f"Fuzzy Matched ({len(fuzzy_corrections)})") duplicates = diagnostics.get('duplicates_collapsed', {}) if duplicates: issues.append(f"Duplicates Collapsed ({len(duplicates)})") illegal_dropped = diagnostics.get('illegal_dropped', []) if illegal_dropped: issues.append(f"Illegal Cards Dropped ({len(illegal_dropped)})") if issues: print("\n⚠ Validation Issues:") if fuzzy_corrections: print(" ⚡ Fuzzy Matched:") for original, corrected in fuzzy_corrections.items(): print(f" • {original} → {corrected}") if duplicates: print(" Duplicates Collapsed:") for card, count in duplicates.items(): print(f" • {card} ({count}x)") if illegal_dropped: print(" Illegal Cards Dropped:") for card in illegal_dropped: print(f" • {card}") print("=" * 50) def _export_outputs(builder: DeckBuilder) -> None: # M4: Print include/exclude summary to console _print_include_exclude_summary(builder) csv_path: Optional[str] = None try: csv_path = builder.export_decklist_csv() if hasattr(builder, "export_decklist_csv") else None except Exception: csv_path = None try: if hasattr(builder, "export_decklist_text"): if csv_path: base = os.path.splitext(os.path.basename(csv_path))[0] builder.export_decklist_text(filename=base + ".txt") else: builder.export_decklist_text() except Exception: pass if _should_export_json_headless() and hasattr(builder, "export_run_config_json") and csv_path: try: base = os.path.splitext(os.path.basename(csv_path))[0] dest = os.getenv("DECK_CONFIG") if dest and dest.lower().endswith(".json"): out_dir, out_name = os.path.dirname(dest) or ".", os.path.basename(dest) os.makedirs(out_dir, exist_ok=True) builder.export_run_config_json(directory=out_dir, filename=out_name) else: out_dir = (dest if dest and os.path.isdir(dest) else "config") os.makedirs(out_dir, exist_ok=True) builder.export_run_config_json(directory=out_dir, filename=base + ".json") except Exception: pass def _parse_bool(val: Optional[str | bool | int]) -> Optional[bool]: if val is None: return None if isinstance(val, bool): return val if isinstance(val, int): return bool(val) s = str(val).strip().lower() if s in {"1", "true", "t", "yes", "y", "on"}: return True if s in {"0", "false", "f", "no", "n", "off"}: return False return None def _parse_card_list(val: Optional[str]) -> List[str]: """Parse comma or semicolon-separated card list from CLI argument.""" if not val: return [] # Support semicolon separation for card names with commas if ';' in val: return [card.strip() for card in val.split(';') if card.strip()] # Use the intelligent parsing for comma-separated (handles card names with commas) try: from deck_builder.include_exclude_utils import parse_card_list_input return parse_card_list_input(val) except ImportError: # Fallback to simple comma split if import fails return [card.strip() for card in val.split(',') if card.strip()] def _parse_opt_int(val: Optional[str | int]) -> Optional[int]: if val is None: return None if isinstance(val, int): return val s = str(val).strip().lower() if s in {"", "none", "null", "nan"}: return None return int(s) def _load_json_config(path: Optional[str]) -> Dict[str, Any]: if not path: return {} try: with open(path, "r", encoding="utf-8") as f: data = json.load(f) if not isinstance(data, dict): raise ValueError("JSON config must be an object") return data except FileNotFoundError: raise def _build_arg_parser() -> argparse.ArgumentParser: p = argparse.ArgumentParser(description="Headless deck builder runner") p.add_argument("--config", metavar="PATH", default=os.getenv("DECK_CONFIG"), help="Path to JSON config file (string)") p.add_argument("--commander", metavar="NAME", default=None, help="Commander name to search for (string)") p.add_argument("--primary-choice", metavar="INT", type=int, default=None, help="Primary theme tag choice number (integer)") p.add_argument("--secondary-choice", metavar="INT", type=_parse_opt_int, default=None, help="Secondary theme tag choice number (integer, optional)") p.add_argument("--tertiary-choice", metavar="INT", type=_parse_opt_int, default=None, help="Tertiary theme tag choice number (integer, optional)") p.add_argument("--primary-tag", metavar="NAME", default=None, help="Primary theme tag name (string, alternative to --primary-choice)") p.add_argument("--secondary-tag", metavar="NAME", default=None, help="Secondary theme tag name (string, alternative to --secondary-choice)") p.add_argument("--tertiary-tag", metavar="NAME", default=None, help="Tertiary theme tag name (string, alternative to --tertiary-choice)") p.add_argument("--bracket-level", metavar="1-5", type=int, default=None, help="Power bracket level 1-5 (integer)") # Ideal count arguments - new feature! ideal_group = p.add_argument_group("Ideal Deck Composition", "Override default target counts for deck categories") ideal_group.add_argument("--ramp-count", metavar="INT", type=int, default=None, help="Target number of ramp spells (integer, default: 8)") ideal_group.add_argument("--land-count", metavar="INT", type=int, default=None, help="Target total number of lands (integer, default: 35)") ideal_group.add_argument("--basic-land-count", metavar="INT", type=int, default=None, help="Minimum number of basic lands (integer, default: 15)") ideal_group.add_argument("--creature-count", metavar="INT", type=int, default=None, help="Target number of creatures (integer, default: 25)") ideal_group.add_argument("--removal-count", metavar="INT", type=int, default=None, help="Target number of spot removal spells (integer, default: 10)") ideal_group.add_argument("--wipe-count", metavar="INT", type=int, default=None, help="Target number of board wipes (integer, default: 2)") ideal_group.add_argument("--card-advantage-count", metavar="INT", type=int, default=None, help="Target number of card advantage pieces (integer, default: 10)") ideal_group.add_argument("--protection-count", metavar="INT", type=int, default=None, help="Target number of protection spells (integer, default: 8)") # Land-specific counts land_group = p.add_argument_group("Land Configuration", "Control specific land type counts and options") land_group.add_argument("--add-lands", metavar="BOOL", type=_parse_bool, default=None, help="Whether to add lands (bool: true/false/1/0)") land_group.add_argument("--fetch-count", metavar="INT", type=_parse_opt_int, default=None, help="Number of fetch lands to include (integer, optional)") land_group.add_argument("--dual-count", metavar="INT", type=_parse_opt_int, default=None, help="Number of dual lands to include (integer, optional)") land_group.add_argument("--triple-count", metavar="INT", type=_parse_opt_int, default=None, help="Number of triple lands to include (integer, optional)") land_group.add_argument("--utility-count", metavar="INT", type=_parse_opt_int, default=None, help="Number of utility lands to include (integer, optional)") # Card type toggles toggle_group = p.add_argument_group("Card Type Toggles", "Enable/disable adding specific card types") toggle_group.add_argument("--add-creatures", metavar="BOOL", type=_parse_bool, default=None, help="Add creatures to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-non-creature-spells", metavar="BOOL", type=_parse_bool, default=None, help="Add non-creature spells to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-ramp", metavar="BOOL", type=_parse_bool, default=None, help="Add ramp spells to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-removal", metavar="BOOL", type=_parse_bool, default=None, help="Add removal spells to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-wipes", metavar="BOOL", type=_parse_bool, default=None, help="Add board wipes to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-card-advantage", metavar="BOOL", type=_parse_bool, default=None, help="Add card advantage pieces to deck (bool: true/false/1/0)") toggle_group.add_argument("--add-protection", metavar="BOOL", type=_parse_bool, default=None, help="Add protection spells to deck (bool: true/false/1/0)") # Include/Exclude configuration include_group = p.add_argument_group("Include/Exclude Cards", "Force include or exclude specific cards") include_group.add_argument("--include-cards", metavar="CARDS", help='Cards to force include (string: comma-separated, max 10). For cards with commas in names like "Krenko, Mob Boss", use semicolons or JSON config.') include_group.add_argument("--exclude-cards", metavar="CARDS", help='Cards to exclude from deck (string: comma-separated, max 15). For cards with commas in names like "Krenko, Mob Boss", use semicolons or JSON config.') include_group.add_argument("--enforcement-mode", metavar="MODE", choices=["warn", "strict"], default=None, help="How to handle missing includes (string: warn=continue, strict=abort)") include_group.add_argument("--allow-illegal", metavar="BOOL", type=_parse_bool, default=None, help="Allow illegal cards in includes/excludes (bool: true/false/1/0)") include_group.add_argument("--fuzzy-matching", metavar="BOOL", type=_parse_bool, default=None, help="Enable fuzzy card name matching (bool: true/false/1/0)") # Utility p.add_argument("--dry-run", action="store_true", help="Print resolved configuration and exit without building") return p def _resolve_value( cli: Optional[Any], env_name: str, json_data: Dict[str, Any], json_key: str, default: Any ) -> Any: if cli is not None: return cli env_val = os.getenv(env_name) if env_val is not None: # Convert types based on default type if isinstance(default, bool): b = _parse_bool(env_val) return default if b is None else b if isinstance(default, int) or default is None: # allow optional ints try: return _parse_opt_int(env_val) except ValueError: return default return env_val if json_key in json_data: return json_data[json_key] return default def _main() -> int: _ensure_data_ready() parser = _build_arg_parser() args = parser.parse_args() # Optional config discovery (no prompts) cfg_path = args.config json_cfg: Dict[str, Any] = {} if cfg_path and os.path.isfile(cfg_path): json_cfg = _load_json_config(cfg_path) else: # No explicit file; if exactly one config exists in a known dir, use it for candidate_dir in [cfg_path] if cfg_path and os.path.isdir(cfg_path) else ["/app/config", "config"]: try: files = [f for f in (os.listdir(candidate_dir) if os.path.isdir(candidate_dir) else []) if f.lower().endswith(".json")] except Exception: files = [] if len(files) == 1: chosen = os.path.join(candidate_dir, files[0]) json_cfg = _load_json_config(chosen) os.environ["DECK_CONFIG"] = chosen break # Defaults mirror run() signature defaults = dict( command_name="", add_creatures=True, add_non_creature_spells=True, add_ramp=True, add_removal=True, add_wipes=True, add_card_advantage=True, add_protection=True, primary_choice=1, secondary_choice=None, tertiary_choice=None, add_lands=True, fetch_count=3, dual_count=None, triple_count=None, utility_count=None, ) # Pull optional ideal_counts from JSON if present ideal_counts_json = {} try: if isinstance(json_cfg.get("ideal_counts"), dict): ideal_counts_json = json_cfg["ideal_counts"] except Exception: ideal_counts_json = {} # Build ideal_counts dict from CLI args, JSON, or defaults ideal_counts_resolved = {} ideal_mappings = [ ("ramp_count", "ramp", 8), ("land_count", "lands", 35), ("basic_land_count", "basic_lands", 15), ("creature_count", "creatures", 25), ("removal_count", "removal", 10), ("wipe_count", "wipes", 2), ("card_advantage_count", "card_advantage", 10), ("protection_count", "protection", 8), ] for cli_key, json_key, default_val in ideal_mappings: cli_val = getattr(args, cli_key, None) if cli_val is not None: ideal_counts_resolved[json_key] = cli_val elif json_key in ideal_counts_json: ideal_counts_resolved[json_key] = ideal_counts_json[json_key] # Don't set defaults here - let the builder use its own defaults # Pull include/exclude configuration from JSON (M1: Config + Validation + Persistence) include_cards_json = [] exclude_cards_json = [] try: if isinstance(json_cfg.get("include_cards"), list): include_cards_json = [str(x) for x in json_cfg["include_cards"] if x] if isinstance(json_cfg.get("exclude_cards"), list): exclude_cards_json = [str(x) for x in json_cfg["exclude_cards"] if x] except Exception: pass # M4: Parse CLI include/exclude card lists cli_include_cards = _parse_card_list(args.include_cards) if hasattr(args, 'include_cards') else [] cli_exclude_cards = _parse_card_list(args.exclude_cards) if hasattr(args, 'exclude_cards') else [] # Resolve tag names to indices BEFORE building resolved dict (so they can override defaults) resolved_primary_choice = args.primary_choice resolved_secondary_choice = args.secondary_choice resolved_tertiary_choice = args.tertiary_choice try: # Collect tag names from CLI, JSON, and environment (CLI takes precedence) primary_tag_name = ( args.primary_tag or (str(os.getenv("DECK_PRIMARY_TAG") or "").strip()) or str(json_cfg.get("primary_tag", "")).strip() ) secondary_tag_name = ( args.secondary_tag or (str(os.getenv("DECK_SECONDARY_TAG") or "").strip()) or str(json_cfg.get("secondary_tag", "")).strip() ) tertiary_tag_name = ( args.tertiary_tag or (str(os.getenv("DECK_TERTIARY_TAG") or "").strip()) or str(json_cfg.get("tertiary_tag", "")).strip() ) tag_names = [t for t in [primary_tag_name, secondary_tag_name, tertiary_tag_name] if t] if tag_names: # Load commander name to resolve tags commander_name = _resolve_value(args.commander, "DECK_COMMANDER", json_cfg, "commander", "") if commander_name: try: # Load commander tags to compute indices tmp = DeckBuilder() df = tmp.load_commander_data() row = df[df["name"] == commander_name] if not row.empty: original = list(dict.fromkeys(row.iloc[0].get("themeTags", []) or [])) # Step 1: primary from original if primary_tag_name: for i, t in enumerate(original, start=1): if str(t).strip().lower() == primary_tag_name.strip().lower(): resolved_primary_choice = i break # Step 2: secondary from remaining after primary if secondary_tag_name: if resolved_primary_choice is not None: # Create remaining list after removing primary choice remaining_1 = [t for j, t in enumerate(original, start=1) if j != resolved_primary_choice] for i2, t in enumerate(remaining_1, start=1): if str(t).strip().lower() == secondary_tag_name.strip().lower(): resolved_secondary_choice = i2 break else: # If no primary set, secondary maps directly to original list for i, t in enumerate(original, start=1): if str(t).strip().lower() == secondary_tag_name.strip().lower(): resolved_secondary_choice = i break # Step 3: tertiary from remaining after primary+secondary if tertiary_tag_name: if resolved_primary_choice is not None and resolved_secondary_choice is not None: # reconstruct remaining after removing primary then secondary as displayed remaining_1 = [t for j, t in enumerate(original, start=1) if j != resolved_primary_choice] remaining_2 = [t for j, t in enumerate(remaining_1, start=1) if j != resolved_secondary_choice] for i3, t in enumerate(remaining_2, start=1): if str(t).strip().lower() == tertiary_tag_name.strip().lower(): resolved_tertiary_choice = i3 break elif resolved_primary_choice is not None: # Only primary set, tertiary from remaining after primary remaining_1 = [t for j, t in enumerate(original, start=1) if j != resolved_primary_choice] for i, t in enumerate(remaining_1, start=1): if str(t).strip().lower() == tertiary_tag_name.strip().lower(): resolved_tertiary_choice = i break else: # No primary or secondary set, tertiary maps directly to original list for i, t in enumerate(original, start=1): if str(t).strip().lower() == tertiary_tag_name.strip().lower(): resolved_tertiary_choice = i break except Exception: pass except Exception: pass resolved = { "command_name": _resolve_value(args.commander, "DECK_COMMANDER", json_cfg, "commander", defaults["command_name"]), "add_creatures": _resolve_value(args.add_creatures, "DECK_ADD_CREATURES", json_cfg, "add_creatures", defaults["add_creatures"]), "add_non_creature_spells": _resolve_value(args.add_non_creature_spells, "DECK_ADD_NON_CREATURE_SPELLS", json_cfg, "add_non_creature_spells", defaults["add_non_creature_spells"]), "add_ramp": _resolve_value(args.add_ramp, "DECK_ADD_RAMP", json_cfg, "add_ramp", defaults["add_ramp"]), "add_removal": _resolve_value(args.add_removal, "DECK_ADD_REMOVAL", json_cfg, "add_removal", defaults["add_removal"]), "add_wipes": _resolve_value(args.add_wipes, "DECK_ADD_WIPES", json_cfg, "add_wipes", defaults["add_wipes"]), "add_card_advantage": _resolve_value(args.add_card_advantage, "DECK_ADD_CARD_ADVANTAGE", json_cfg, "add_card_advantage", defaults["add_card_advantage"]), "add_protection": _resolve_value(args.add_protection, "DECK_ADD_PROTECTION", json_cfg, "add_protection", defaults["add_protection"]), "primary_choice": _resolve_value(resolved_primary_choice, "DECK_PRIMARY_CHOICE", json_cfg, "primary_choice", defaults["primary_choice"]), "secondary_choice": _resolve_value(resolved_secondary_choice, "DECK_SECONDARY_CHOICE", json_cfg, "secondary_choice", defaults["secondary_choice"]), "tertiary_choice": _resolve_value(resolved_tertiary_choice, "DECK_TERTIARY_CHOICE", json_cfg, "tertiary_choice", defaults["tertiary_choice"]), "bracket_level": _resolve_value(args.bracket_level, "DECK_BRACKET_LEVEL", json_cfg, "bracket_level", None), "add_lands": _resolve_value(args.add_lands, "DECK_ADD_LANDS", json_cfg, "add_lands", defaults["add_lands"]), "fetch_count": _resolve_value(args.fetch_count, "DECK_FETCH_COUNT", json_cfg, "fetch_count", defaults["fetch_count"]), "dual_count": _resolve_value(args.dual_count, "DECK_DUAL_COUNT", json_cfg, "dual_count", defaults["dual_count"]), "triple_count": _resolve_value(args.triple_count, "DECK_TRIPLE_COUNT", json_cfg, "triple_count", defaults["triple_count"]), "utility_count": _resolve_value(args.utility_count, "DECK_UTILITY_COUNT", json_cfg, "utility_count", defaults["utility_count"]), "ideal_counts": ideal_counts_resolved, # M4: Include/Exclude configuration (CLI + JSON + Env priority) "include_cards": cli_include_cards or include_cards_json, "exclude_cards": cli_exclude_cards or exclude_cards_json, "enforcement_mode": args.enforcement_mode or json_cfg.get("enforcement_mode", "warn"), "allow_illegal": args.allow_illegal if args.allow_illegal is not None else bool(json_cfg.get("allow_illegal", False)), "fuzzy_matching": args.fuzzy_matching if args.fuzzy_matching is not None else bool(json_cfg.get("fuzzy_matching", True)), } if args.dry_run: print(json.dumps(resolved, indent=2)) return 0 if not str(resolved.get("command_name", "")).strip(): print("Error: commander is required. Provide --commander or a JSON config with a 'commander' field.") return 2 run(**resolved) return 0 if __name__ == "__main__": raise SystemExit(_main())