adversarial-workflow 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

adversarial_workflow/__init__.py

@@ -12,7 +12,7 @@ Usage:
     adversarial validate "pytest"
 """
 
-__version__ = "0.6.1"
+__version__ = "0.6.2"
 __author__ = "Fredrik Matheson"
 __license__ = "MIT"
 

adversarial_workflow/__main__.py

@@ -1,4 +1,5 @@
 """Allow execution via python -m adversarial_workflow."""
+
 from .cli import main
 
 if __name__ == "__main__":

adversarial_workflow/cli.py

@@ -27,9 +27,9 @@ from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 import yaml
-from dotenv import load_dotenv, dotenv_values
+from dotenv import dotenv_values, load_dotenv
 
-__version__ = "0.6.1"
+__version__ = "0.6.2"
 
 # ANSI color codes for better output
 RESET = "\033[0m"
@@ -322,16 +322,20 @@ def init_interactive(project_path: str = ".") -> int:
         f"{GREEN}✅ Setup Complete!{RESET}",
         [
             "Created:",
-            "  ✓ .env (with your API keys - added to .gitignore)"
-            if (anthropic_key or openai_key)
-            else "  ⚠️ .env (skipped - no API keys provided)",
+            (
+                "  ✓ .env (with your API keys - added to .gitignore)"
+                if (anthropic_key or openai_key)
+                else "  ⚠️ .env (skipped - no API keys provided)"
+            ),
             "  ✓ .adversarial/config.yml",
             "  ✓ .adversarial/scripts/ (3 workflow scripts)",
             "  ✓ .aider.conf.yml (aider configuration)",
             "",
-            "Your configuration:"
-            if (anthropic_key or openai_key)
-            else "Configuration (no API keys yet):",
+            (
+                "Your configuration:"
+                if (anthropic_key or openai_key)
+                else "Configuration (no API keys yet):"
+            ),
             f"  Author (implementation): {'Claude 3.5 Sonnet (Anthropic)' if anthropic_key else 'GPT-4o (OpenAI)' if openai_key else 'Not configured'}",
             f"  Evaluator: {'GPT-4o (OpenAI)' if openai_key else 'Claude 3.5 Sonnet (Anthropic)' if anthropic_key else 'Not configured'}",
             f"  Cost per workflow: {'~$0.02-0.10' if (anthropic_key and openai_key) else '~$0.05-0.15' if (anthropic_key or openai_key) else 'N/A'}",
@@ -806,15 +810,14 @@ def check() -> int:
 
     if env_file.exists():
         try:
-            # Load .env into environment (idempotent - safe to call again after main())
-            load_dotenv(env_file)
-            # Use dotenv_values() to count variables directly from file
-            # This gives accurate count regardless of what was already in environment
+            # Count variables by reading file directly (works even if already loaded)
             env_vars = dotenv_values(env_file)
+            var_count = len([k for k, v in env_vars.items() if v is not None])
+
+            # Still load to ensure environment is set
+            load_dotenv(env_file)
             env_loaded = True
-            good_checks.append(
-                f".env file found ({len(env_vars)} variables configured)"
-            )
+            good_checks.append(f".env file found and loaded ({var_count} variables)")
         except (FileNotFoundError, PermissionError) as e:
             # File access errors
             issues.append(
@@ -2097,10 +2100,6 @@ def evaluate(task_file: str) -> int:
         return 0
 
 
-
-
-
-
 def review() -> int:
     """Run Phase 3: Code review."""
 
@@ -2289,7 +2288,9 @@ def fetch_agent_template(url: str, template_type: str = "standard") -> Optional[
                 )
                 return None
         else:
-            print(f"{RED}❌ ERROR: {template_type} template not found in package{RESET}")
+            print(
+                f"{RED}❌ ERROR: {template_type} template not found in package{RESET}"
+            )
             return None
 
     elif template_type == "custom" and url:
@@ -2739,54 +2740,61 @@ def agent_onboard(project_path: str = ".") -> int:
     return 0
 
 
-def split(task_file: str, strategy: str = "sections", max_lines: int = 500, dry_run: bool = False):
+def split(
+    task_file: str,
+    strategy: str = "sections",
+    max_lines: int = 500,
+    dry_run: bool = False,
+):
     """Split large task files into smaller evaluable chunks.
-    
+
     Args:
         task_file: Path to the task file to split
         strategy: Split strategy ('sections', 'phases', or 'manual')
         max_lines: Maximum lines per split (default: 500)
         dry_run: Preview splits without creating files
-        
+
     Returns:
         Exit code (0 for success, 1 for error)
     """
     from .utils.file_splitter import (
-        analyze_task_file, 
-        split_by_sections, 
-        split_by_phases, 
-        generate_split_files
+        analyze_task_file,
+        generate_split_files,
+        split_by_phases,
+        split_by_sections,
     )
-    
+
     try:
         print_box("File Splitting Utility", CYAN)
-        
+
         # Validate file exists
         if not os.path.exists(task_file):
             print(f"{RED}Error: File not found: {task_file}{RESET}")
             return 1
-        
+
         # Analyze file
         print(f"📄 Analyzing task file: {task_file}")
         analysis = analyze_task_file(task_file)
-        
-        lines = analysis['total_lines']
-        tokens = analysis['estimated_tokens']
+
+        lines = analysis["total_lines"]
+        tokens = analysis["estimated_tokens"]
         print(f"   Lines: {lines}")
         print(f"   Estimated tokens: ~{tokens:,}")
-        
+
         # Check if splitting is recommended
         if lines <= max_lines:
-            print(f"{GREEN}✅ File is under recommended limit ({max_lines} lines){RESET}")
+            print(
+                f"{GREEN}✅ File is under recommended limit ({max_lines} lines){RESET}"
+            )
             print("No splitting needed.")
             return 0
-        
+
         print(f"{YELLOW}⚠️  File exceeds recommended limit ({max_lines} lines){RESET}")
-        
+
         # Read file content for splitting
-        with open(task_file, 'r', encoding='utf-8') as f:
+        with open(task_file, "r", encoding="utf-8") as f:
             content = f.read()
-        
+
         # Apply split strategy
         if strategy == "sections":
             splits = split_by_sections(content, max_lines=max_lines)
@@ -2795,42 +2803,44 @@ def split(task_file: str, strategy: str = "sections", max_lines: int = 500, dry_
             splits = split_by_phases(content)
             print(f"\n💡 Suggested splits (by phases):")
         else:
-            print(f"{RED}Error: Unknown strategy '{strategy}'. Use 'sections' or 'phases'.{RESET}")
+            print(
+                f"{RED}Error: Unknown strategy '{strategy}'. Use 'sections' or 'phases'.{RESET}"
+            )
             return 1
-        
+
         # Display split preview
         for i, split in enumerate(splits, 1):
             filename = f"{Path(task_file).stem}-part{i}{Path(task_file).suffix}"
             print(f"   - {filename} ({split['line_count']} lines)")
-        
+
         # Dry run mode
         if dry_run:
             print(f"\n{CYAN}📋 Dry run mode - no files created{RESET}")
             return 0
-        
+
         # Prompt user for confirmation
         create_files = prompt_user(f"\nCreate {len(splits)} files?", default="n")
-        
-        if create_files.lower() in ['y', 'yes']:
+
+        if create_files.lower() in ["y", "yes"]:
             # Create output directory
             output_dir = os.path.join(os.path.dirname(task_file), "splits")
-            
+
             # Generate split files
             created_files = generate_split_files(task_file, splits, output_dir)
-            
+
             print(f"{GREEN}✅ Created {len(created_files)} files:{RESET}")
             for file_path in created_files:
                 print(f"   {file_path}")
-            
+
             print(f"\n{CYAN}💡 Tip: Evaluate each split file independently:{RESET}")
             for file_path in created_files:
                 rel_path = os.path.relpath(file_path)
                 print(f"   adversarial evaluate {rel_path}")
         else:
             print("Cancelled - no files created.")
-        
+
         return 0
-        
+
     except Exception as e:
         print(f"{RED}Error during file splitting: {e}{RESET}")
         return 1
@@ -2876,6 +2886,7 @@ def list_evaluators() -> int:
 
     return 0
 
+
 def main():
     """Main CLI entry point."""
     import logging
@@ -2888,10 +2899,20 @@ def main():
     except Exception as e:
         print(f"Warning: Could not load .env file: {e}", file=sys.stderr)
 
+    # Load .env file before any commands run
+    # Use explicit path to ensure we find .env in current working directory
+    # (load_dotenv() without args can fail to find .env in some contexts)
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        try:
+            load_dotenv(env_file)
+        except (OSError, UnicodeDecodeError) as e:
+            print(f"Warning: Could not load .env file: {e}", file=sys.stderr)
+
     from adversarial_workflow.evaluators import (
+        BUILTIN_EVALUATORS,
         get_all_evaluators,
         run_evaluator,
-        BUILTIN_EVALUATORS,
     )
 
     logger = logging.getLogger(__name__)
@@ -2899,8 +2920,16 @@ def main():
     # Commands that cannot be overridden by evaluators
     # Note: 'review' is special - it reviews git changes without a file argument
     STATIC_COMMANDS = {
-        "init", "check", "doctor", "health", "quickstart",
-        "agent", "split", "validate", "review", "list-evaluators"
+        "init",
+        "check",
+        "doctor",
+        "health",
+        "quickstart",
+        "agent",
+        "split",
+        "validate",
+        "review",
+        "list-evaluators",
     }
 
     parser = argparse.ArgumentParser(
@@ -2989,16 +3018,21 @@ For more information: https://github.com/movito/adversarial-workflow
     )
     split_parser.add_argument("task_file", help="Task file to split")
     split_parser.add_argument(
-        "--strategy", "-s", choices=["sections", "phases"], default="sections",
-        help="Split strategy: 'sections' (default) or 'phases'"
+        "--strategy",
+        "-s",
+        choices=["sections", "phases"],
+        default="sections",
+        help="Split strategy: 'sections' (default) or 'phases'",
     )
     split_parser.add_argument(
-        "--max-lines", "-m", type=int, default=500,
-        help="Maximum lines per split (default: 500)"
+        "--max-lines",
+        "-m",
+        type=int,
+        default=500,
+        help="Maximum lines per split (default: 500)",
     )
     split_parser.add_argument(
-        "--dry-run", action="store_true",
-        help="Preview splits without creating files"
+        "--dry-run", action="store_true", help="Preview splits without creating files"
     )
 
     # list-evaluators command
@@ -3019,7 +3053,12 @@ For more information: https://github.com/movito/adversarial-workflow
     for name, config in evaluators.items():
         # Skip if name conflicts with static command
         if name in STATIC_COMMANDS:
-            logger.warning("Evaluator '%s' conflicts with CLI command; skipping", name)
+            # Only warn for user-defined evaluators, not built-ins
+            # Built-in conflicts are intentional (e.g., 'review' command vs 'review' evaluator)
+            if getattr(config, "source", None) != "builtin":
+                logger.warning(
+                    "Evaluator '%s' conflicts with CLI command; skipping", name
+                )
             # Mark as registered to prevent alias re-registration attempts
             registered_configs.add(id(config))
             continue
@@ -3046,10 +3085,11 @@ For more information: https://github.com/movito/adversarial-workflow
         )
         eval_parser.add_argument("file", help="File to evaluate")
         eval_parser.add_argument(
-            "--timeout", "-t",
+            "--timeout",
+            "-t",
             type=int,
-            default=180,
-            help="Timeout in seconds (default: 180)"
+            default=None,
+            help="Timeout in seconds (default: from evaluator config or 180, max: 600)",
         )
         # Store config for later execution
         eval_parser.set_defaults(evaluator_config=config)
@@ -3062,10 +3102,34 @@ For more information: https://github.com/movito/adversarial-workflow
 
     # Check for evaluator command first (has evaluator_config attribute)
     if hasattr(args, "evaluator_config"):
+        # Determine timeout: CLI flag > YAML config > default (180s)
+        if args.timeout is not None:
+            timeout = args.timeout
+            source = "CLI override"
+        elif args.evaluator_config.timeout != 180:
+            timeout = args.evaluator_config.timeout
+            source = "evaluator config"
+        else:
+            timeout = args.evaluator_config.timeout  # 180 (default)
+            source = "default"
+
+        # Validate CLI timeout (consistent with YAML validation)
+        if timeout <= 0:
+            print(f"{RED}Error: Timeout must be positive (> 0), got {timeout}{RESET}")
+            return 1
+        if timeout > 600:
+            print(
+                f"{YELLOW}Warning: Timeout {timeout}s exceeds maximum (600s), clamping to 600s{RESET}"
+            )
+            timeout = 600
+
+        # Log actual timeout and source
+        print(f"Using timeout: {timeout}s ({source})")
+
         return run_evaluator(
             args.evaluator_config,
             args.file,
-            timeout=args.timeout,
+            timeout=timeout,
         )
 
     # Execute static commands
@@ -3097,7 +3161,7 @@ For more information: https://github.com/movito/adversarial-workflow
             args.task_file,
             strategy=args.strategy,
             max_lines=args.max_lines,
-            dry_run=args.dry_run
+            dry_run=args.dry_run,
         )
     elif args.command == "list-evaluators":
         return list_evaluators()

adversarial_workflow/evaluators/__init__.py

@@ -1,13 +1,13 @@
 """Evaluators module for adversarial-workflow plugin architecture."""
 
+from .builtins import BUILTIN_EVALUATORS
 from .config import EvaluatorConfig
 from .discovery import (
+    EvaluatorParseError,
     discover_local_evaluators,
     parse_evaluator_yaml,
-    EvaluatorParseError,
 )
 from .runner import run_evaluator
-from .builtins import BUILTIN_EVALUATORS
 
 
 def get_all_evaluators() -> dict[str, EvaluatorConfig]:
@@ -17,6 +17,7 @@ def get_all_evaluators() -> dict[str, EvaluatorConfig]:
     Aliases from local evaluators are also included in the returned dictionary.
     """
     import logging
+
     logger = logging.getLogger(__name__)
 
     evaluators: dict[str, EvaluatorConfig] = {}

adversarial_workflow/evaluators/config.py

@@ -26,6 +26,7 @@ class EvaluatorConfig:
         fallback_model: Fallback model if primary fails
         aliases: Alternative command names
         version: Evaluator version
+        timeout: Timeout in seconds (default: 180, max: 600)
         source: "builtin" or "local" (set internally)
         config_file: Path to YAML file if local (set internally)
     """
@@ -43,6 +44,7 @@ class EvaluatorConfig:
     fallback_model: str | None = None
     aliases: list[str] = field(default_factory=list)
     version: str = "1.0.0"
+    timeout: int = 180  # Timeout in seconds (default: 180, max: 600)
 
     # Metadata (set internally during discovery, not from YAML)
     source: str = "builtin"

adversarial_workflow/evaluators/discovery.py

@@ -40,9 +40,7 @@ def parse_evaluator_yaml(yml_file: Path) -> EvaluatorConfig:
     try:
         content = yml_file.read_text(encoding="utf-8")
     except UnicodeDecodeError as e:
-        raise EvaluatorParseError(
-            f"File encoding error (not UTF-8): {yml_file}"
-        ) from e
+        raise EvaluatorParseError(f"File encoding error (not UTF-8): {yml_file}") from e
 
     # Parse YAML
     data = yaml.safe_load(content)
@@ -58,7 +56,14 @@ def parse_evaluator_yaml(yml_file: Path) -> EvaluatorConfig:
         )
 
     # Validate required fields exist
-    required = ["name", "description", "model", "api_key_env", "prompt", "output_suffix"]
+    required = [
+        "name",
+        "description",
+        "model",
+        "api_key_env",
+        "prompt",
+        "output_suffix",
+    ]
     missing = [f for f in required if f not in data]
     if missing:
         raise EvaluatorParseError(f"Missing required fields: {', '.join(missing)}")
@@ -117,6 +122,35 @@ def parse_evaluator_yaml(yml_file: Path) -> EvaluatorConfig:
                     f"Field '{field}' must be a string, got {type(value).__name__}: {value!r}"
                 )
 
+    # Validate timeout if present
+    if "timeout" in data:
+        timeout = data["timeout"]
+        # Handle null/empty values
+        if timeout is None or timeout == "":
+            raise EvaluatorParseError("Field 'timeout' cannot be null or empty")
+        # Check for bool before int (bool is subclass of int in Python)
+        # YAML parses 'yes'/'true' as True, 'no'/'false' as False
+        if isinstance(timeout, bool):
+            raise EvaluatorParseError(
+                f"Field 'timeout' must be an integer, got bool: {timeout!r}"
+            )
+        if not isinstance(timeout, int):
+            raise EvaluatorParseError(
+                f"Field 'timeout' must be an integer, got {type(timeout).__name__}: {timeout!r}"
+            )
+        # timeout=0 is invalid (does not disable timeout - use a large value instead)
+        if timeout <= 0:
+            raise EvaluatorParseError(
+                f"Field 'timeout' must be positive (> 0), got {timeout}"
+            )
+        if timeout > 600:
+            logger.warning(
+                "Timeout %ds exceeds maximum (600s), clamping to 600s in %s",
+                timeout,
+                yml_file.name,
+            )
+            data["timeout"] = 600
+
     # Filter to known fields only (log unknown fields)
     known_fields = {
         "name",
@@ -129,6 +163,7 @@ def parse_evaluator_yaml(yml_file: Path) -> EvaluatorConfig:
         "fallback_model",
         "aliases",
         "version",
+        "timeout",
     }
     unknown = set(data.keys()) - known_fields
     if unknown:

adversarial_workflow/evaluators/runner.py

@@ -10,10 +10,10 @@ import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 
-from .config import EvaluatorConfig
-from ..utils.colors import RESET, BOLD, GREEN, YELLOW, RED
+from ..utils.colors import BOLD, GREEN, RED, RESET, YELLOW
 from ..utils.config import load_config
 from ..utils.validation import validate_evaluation_output
+from .config import EvaluatorConfig
 
 
 def run_evaluator(config: EvaluatorConfig, file_path: str, timeout: int = 180) -> int:
@@ -124,7 +124,7 @@ def _run_custom_evaluator(
 """
 
     # Create temp file for prompt
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
         f.write(full_prompt)
         prompt_file = f.name
 
@@ -136,12 +136,15 @@ def _run_custom_evaluator(
         # Build aider command
         cmd = [
             "aider",
-            "--model", config.model,
+            "--model",
+            config.model,
             "--yes",
             "--no-git",
             "--no-auto-commits",
-            "--message-file", prompt_file,
-            "--read", file_path,
+            "--message-file",
+            prompt_file,
+            "--read",
+            file_path,
         ]
 
         result = subprocess.run(
@@ -224,7 +227,10 @@ def _execute_script(
 
     # Validate output
     file_basename = Path(file_path).stem
-    log_file = Path(project_config["log_directory"]) / f"{file_basename}-{config.output_suffix}.md"
+    log_file = (
+        Path(project_config["log_directory"])
+        / f"{file_basename}-{config.output_suffix}.md"
+    )
 
     is_valid, verdict, message = validate_evaluation_output(str(log_file))
 
@@ -235,7 +241,9 @@ def _execute_script(
     return _report_verdict(verdict, log_file, config)
 
 
-def _report_verdict(verdict: str | None, log_file: Path, config: EvaluatorConfig) -> int:
+def _report_verdict(
+    verdict: str | None, log_file: Path, config: EvaluatorConfig
+) -> int:
     """Report the evaluation verdict to terminal."""
     print()
     if verdict == "APPROVED":

adversarial_workflow/utils/file_splitter.py

@@ -4,360 +4,392 @@ This module provides functionality to split large markdown files into smaller,
 independently evaluable chunks to work around OpenAI's rate limits.
 """
 
-import re
 import os
+import re
 from pathlib import Path
-from typing import List, Dict, Any
+from typing import Any, Dict, List
 
 
 def analyze_task_file(file_path: str) -> Dict[str, Any]:
     """Analyze file structure and suggest split points.
-    
+
     Args:
         file_path: Path to the markdown file to analyze
-        
+
     Returns:
         Dict containing:
         - total_lines: Total number of lines
         - sections: List of detected sections with metadata
         - estimated_tokens: Rough token estimate (lines * 4)
         - suggested_splits: List of suggested split points
-        
+
     Raises:
         FileNotFoundError: If file doesn't exist
         ValueError: If file is empty or too small
     """
     if not os.path.exists(file_path):
         raise FileNotFoundError(f"File not found: {file_path}")
-    
-    with open(file_path, 'r', encoding='utf-8') as f:
+
+    with open(file_path, "r", encoding="utf-8") as f:
         content = f.read()
-    
+
     if not content.strip():
         raise ValueError("File is empty or too small")
-    
-    lines = content.split('\n')
+
+    lines = content.split("\n")
     total_lines = len(lines)
-    
+
     # Detect markdown sections
     sections = []
     current_section = None
     current_start = 1
-    
+
     for i, line in enumerate(lines, 1):
         # Check for markdown headings (# or ##)
-        if re.match(r'^#+\s+', line.strip()):
+        if re.match(r"^#+\s+", line.strip()):
             # Close previous section
             if current_section is not None:
-                current_section['end_line'] = i - 1
-                current_section['line_count'] = current_section['end_line'] - current_section['start_line'] + 1
+                current_section["end_line"] = i - 1
+                current_section["line_count"] = (
+                    current_section["end_line"] - current_section["start_line"] + 1
+                )
                 sections.append(current_section)
-            
+
             # Start new section
             heading_level = len(line.lstrip().split()[0])  # Count # characters
-            title = re.sub(r'^#+\s+', '', line.strip())
+            title = re.sub(r"^#+\s+", "", line.strip())
             current_section = {
-                'title': title,
-                'heading_level': heading_level,
-                'start_line': i,
-                'end_line': None,
-                'line_count': 0
+                "title": title,
+                "heading_level": heading_level,
+                "start_line": i,
+                "end_line": None,
+                "line_count": 0,
             }
             current_start = i
-    
+
     # Close final section
     if current_section is not None:
-        current_section['end_line'] = total_lines
-        current_section['line_count'] = current_section['end_line'] - current_section['start_line'] + 1
+        current_section["end_line"] = total_lines
+        current_section["line_count"] = (
+            current_section["end_line"] - current_section["start_line"] + 1
+        )
         sections.append(current_section)
-    
+
     # If no sections found, treat entire file as one section
     if not sections:
-        sections = [{
-            'title': 'Full Document',
-            'heading_level': 1,
-            'start_line': 1,
-            'end_line': total_lines,
-            'line_count': total_lines
-        }]
-    
+        sections = [
+            {
+                "title": "Full Document",
+                "heading_level": 1,
+                "start_line": 1,
+                "end_line": total_lines,
+                "line_count": total_lines,
+            }
+        ]
+
     # Estimate tokens (rough approximation: 1 line ≈ 4 tokens)
     estimated_tokens = total_lines * 4
-    
+
     # Suggest splits if file is large
     suggested_splits = []
     if total_lines > 500:
         # Suggest section-based splits
         suggested_splits = _suggest_section_splits(sections, max_lines=500)
-    
+
     return {
-        'total_lines': total_lines,
-        'sections': sections,
-        'estimated_tokens': estimated_tokens,
-        'suggested_splits': suggested_splits
+        "total_lines": total_lines,
+        "sections": sections,
+        "estimated_tokens": estimated_tokens,
+        "suggested_splits": suggested_splits,
     }
 
 
 def split_by_sections(content: str, max_lines: int = 500) -> List[Dict[str, Any]]:
     """Split file by markdown sections.
-    
+
     Args:
         content: The markdown content to split
         max_lines: Maximum lines per split
-        
+
     Returns:
         List of split dictionaries with metadata
     """
-    lines = content.split('\n')
+    lines = content.split("\n")
     total_lines = len(lines)
-    
+
     if total_lines <= max_lines:
-        return [{
-            'content': content,
-            'title': 'Full Document',
-            'start_line': 1,
-            'end_line': total_lines,
-            'line_count': total_lines
-        }]
-    
+        return [
+            {
+                "content": content,
+                "title": "Full Document",
+                "start_line": 1,
+                "end_line": total_lines,
+                "line_count": total_lines,
+            }
+        ]
+
     splits = []
     current_split_lines = []
     current_start = 1
     current_title = "Part"
     split_count = 1
-    
+
     for i, line in enumerate(lines, 1):
         current_split_lines.append(line)
-        
+
         # Check if we hit a section boundary and are near limit
-        is_section_boundary = re.match(r'^#+\s+', line.strip())
+        is_section_boundary = re.match(r"^#+\s+", line.strip())
         approaching_limit = len(current_split_lines) >= max_lines * 0.8
-        
-        if len(current_split_lines) >= max_lines or (is_section_boundary and approaching_limit):
+
+        if len(current_split_lines) >= max_lines or (
+            is_section_boundary and approaching_limit
+        ):
             # Create split
-            split_content = '\n'.join(current_split_lines)
-            splits.append({
-                'content': split_content,
-                'title': f"Part {split_count}",
-                'start_line': current_start,
-                'end_line': i,
-                'line_count': len(current_split_lines)
-            })
-            
+            split_content = "\n".join(current_split_lines)
+            splits.append(
+                {
+                    "content": split_content,
+                    "title": f"Part {split_count}",
+                    "start_line": current_start,
+                    "end_line": i,
+                    "line_count": len(current_split_lines),
+                }
+            )
+
             # Reset for next split
             current_split_lines = []
             current_start = i + 1
             split_count += 1
-    
+
     # Handle remaining lines
     if current_split_lines:
-        split_content = '\n'.join(current_split_lines)
-        splits.append({
-            'content': split_content,
-            'title': f"Part {split_count}",
-            'start_line': current_start,
-            'end_line': total_lines,
-            'line_count': len(current_split_lines)
-        })
-    
+        split_content = "\n".join(current_split_lines)
+        splits.append(
+            {
+                "content": split_content,
+                "title": f"Part {split_count}",
+                "start_line": current_start,
+                "end_line": total_lines,
+                "line_count": len(current_split_lines),
+            }
+        )
+
     return splits
 
 
 def split_by_phases(content: str) -> List[Dict[str, Any]]:
     """Split file by implementation phases.
-    
+
     Args:
         content: The markdown content to split
-        
+
     Returns:
         List of split dictionaries, one per phase
     """
-    lines = content.split('\n')
+    lines = content.split("\n")
     splits = []
     current_split_lines = []
     current_phase = None
     current_start = 1
-    
+
     for i, line in enumerate(lines, 1):
         # Check for phase markers
-        phase_match = re.search(r'#+\s+Phase\s+(\d+)', line, re.IGNORECASE)
-        
+        phase_match = re.search(r"#+\s+Phase\s+(\d+)", line, re.IGNORECASE)
+
         if phase_match:
             # Close previous split
             if current_split_lines:
-                split_content = '\n'.join(current_split_lines)
+                split_content = "\n".join(current_split_lines)
                 title = f"Phase {current_phase}" if current_phase else "Overview"
-                splits.append({
-                    'content': split_content,
-                    'title': title,
-                    'phase_number': current_phase,
-                    'start_line': current_start,
-                    'end_line': i - 1,
-                    'line_count': len(current_split_lines)
-                })
-            
+                splits.append(
+                    {
+                        "content": split_content,
+                        "title": title,
+                        "phase_number": current_phase,
+                        "start_line": current_start,
+                        "end_line": i - 1,
+                        "line_count": len(current_split_lines),
+                    }
+                )
+
             # Start new split
             current_phase = int(phase_match.group(1))
             current_split_lines = [line]
             current_start = i
         else:
             current_split_lines.append(line)
-    
+
     # Handle final split
     if current_split_lines:
-        split_content = '\n'.join(current_split_lines)
+        split_content = "\n".join(current_split_lines)
         title = f"Phase {current_phase}" if current_phase else "Full Document"
-        phase_info = {'phase_number': current_phase} if current_phase else {}
-        splits.append({
-            'content': split_content,
-            'title': title,
-            'start_line': current_start,
-            'end_line': len(lines),
-            'line_count': len(current_split_lines),
-            **phase_info
-        })
-    
+        phase_info = {"phase_number": current_phase} if current_phase else {}
+        splits.append(
+            {
+                "content": split_content,
+                "title": title,
+                "start_line": current_start,
+                "end_line": len(lines),
+                "line_count": len(current_split_lines),
+                **phase_info,
+            }
+        )
+
     # If no phases found, return entire content
     if not splits:
-        splits = [{
-            'content': content,
-            'title': 'Full Document',
-            'start_line': 1,
-            'end_line': len(lines),
-            'line_count': len(lines)
-        }]
-    
+        splits = [
+            {
+                "content": content,
+                "title": "Full Document",
+                "start_line": 1,
+                "end_line": len(lines),
+                "line_count": len(lines),
+            }
+        ]
+
     return splits
 
 
 def split_at_lines(content: str, line_numbers: List[int]) -> List[Dict[str, Any]]:
     """Split at specified line numbers.
-    
+
     Args:
         content: The content to split
         line_numbers: Line numbers where splits should occur
-        
+
     Returns:
         List of split dictionaries
     """
-    lines = content.split('\n')
+    lines = content.split("\n")
     total_lines = len(lines)
-    
+
     if not line_numbers:
-        return [{
-            'content': content,
-            'title': 'Full Document',
-            'start_line': 1,
-            'end_line': total_lines,
-            'line_count': total_lines
-        }]
-    
+        return [
+            {
+                "content": content,
+                "title": "Full Document",
+                "start_line": 1,
+                "end_line": total_lines,
+                "line_count": total_lines,
+            }
+        ]
+
     # Sort and deduplicate line numbers
     split_points = sorted(set(line_numbers))
-    
+
     splits = []
     current_start = 1
-    
+
     for split_line in split_points:
         if split_line >= total_lines:
             continue
-            
+
         # Create split from current_start to split_line
-        split_lines = lines[current_start - 1:split_line]
-        split_content = '\n'.join(split_lines)
-        
-        splits.append({
-            'content': split_content,
-            'title': f"Lines {current_start}-{split_line}",
-            'start_line': current_start,
-            'end_line': split_line,
-            'line_count': len(split_lines)
-        })
-        
+        split_lines = lines[current_start - 1 : split_line]
+        split_content = "\n".join(split_lines)
+
+        splits.append(
+            {
+                "content": split_content,
+                "title": f"Lines {current_start}-{split_line}",
+                "start_line": current_start,
+                "end_line": split_line,
+                "line_count": len(split_lines),
+            }
+        )
+
         current_start = split_line + 1
-    
+
     # Handle remaining lines after final split
     if current_start <= total_lines:
-        remaining_lines = lines[current_start - 1:]
-        split_content = '\n'.join(remaining_lines)
-        
-        splits.append({
-            'content': split_content,
-            'title': f"Lines {current_start}-{total_lines}",
-            'start_line': current_start,
-            'end_line': total_lines,
-            'line_count': len(remaining_lines)
-        })
-    
+        remaining_lines = lines[current_start - 1 :]
+        split_content = "\n".join(remaining_lines)
+
+        splits.append(
+            {
+                "content": split_content,
+                "title": f"Lines {current_start}-{total_lines}",
+                "start_line": current_start,
+                "end_line": total_lines,
+                "line_count": len(remaining_lines),
+            }
+        )
+
     return splits
 
 
-def generate_split_files(original: str, splits: List[Dict[str, Any]], output_dir: str) -> List[str]:
+def generate_split_files(
+    original: str, splits: List[Dict[str, Any]], output_dir: str
+) -> List[str]:
     """Generate split files with metadata and cross-references.
-    
+
     Args:
         original: Original filename
         splits: List of split dictionaries
         output_dir: Directory to write split files
-        
+
     Returns:
         List of created file paths
     """
     os.makedirs(output_dir, exist_ok=True)
-    
+
     created_files = []
     original_name = Path(original).stem
     original_ext = Path(original).suffix
-    
+
     for i, split in enumerate(splits, 1):
         # Generate filename
         filename = f"{original_name}-part{i}{original_ext}"
         file_path = os.path.join(output_dir, filename)
-        
+
         # Create content with metadata header
         metadata_header = f"""<!-- Split from {original} -->
 <!-- Part {i} of {len(splits)} -->
 <!-- Lines {split['start_line']}-{split['end_line']} ({split['line_count']} lines) -->
 
 """
-        
-        full_content = metadata_header + split['content']
-        
+
+        full_content = metadata_header + split["content"]
+
         # Write file
-        with open(file_path, 'w', encoding='utf-8') as f:
+        with open(file_path, "w", encoding="utf-8") as f:
             f.write(full_content)
-        
+
         created_files.append(file_path)
-    
+
     return created_files
 
 
-def _suggest_section_splits(sections: List[Dict[str, Any]], max_lines: int = 500) -> List[Dict[str, Any]]:
+def _suggest_section_splits(
+    sections: List[Dict[str, Any]], max_lines: int = 500
+) -> List[Dict[str, Any]]:
     """Suggest optimal split points based on sections.
-    
+
     Args:
         sections: List of section metadata
         max_lines: Maximum lines per split
-        
+
     Returns:
         List of suggested split configurations
     """
     suggestions = []
     current_chunk_lines = 0
     current_chunk_sections = []
-    
+
     for section in sections:
-        section_lines = section['line_count']
-        
+        section_lines = section["line_count"]
+
         # If adding this section would exceed limit, finish current chunk
         if current_chunk_lines + section_lines > max_lines and current_chunk_sections:
-            suggestions.append({
-                'sections': current_chunk_sections.copy(),
-                'total_lines': current_chunk_lines,
-                'start_line': current_chunk_sections[0]['start_line'],
-                'end_line': current_chunk_sections[-1]['end_line']
-            })
-            
+            suggestions.append(
+                {
+                    "sections": current_chunk_sections.copy(),
+                    "total_lines": current_chunk_lines,
+                    "start_line": current_chunk_sections[0]["start_line"],
+                    "end_line": current_chunk_sections[-1]["end_line"],
+                }
+            )
+
             # Start new chunk
             current_chunk_sections = [section]
             current_chunk_lines = section_lines
@@ -365,14 +397,16 @@ def _suggest_section_splits(sections: List[Dict[str, Any]], max_lines: int = 500
             # Add section to current chunk
             current_chunk_sections.append(section)
             current_chunk_lines += section_lines
-    
+
     # Add final chunk
     if current_chunk_sections:
-        suggestions.append({
-            'sections': current_chunk_sections,
-            'total_lines': current_chunk_lines,
-            'start_line': current_chunk_sections[0]['start_line'],
-            'end_line': current_chunk_sections[-1]['end_line']
-        })
-    
-    return suggestions
+        suggestions.append(
+            {
+                "sections": current_chunk_sections,
+                "total_lines": current_chunk_lines,
+                "start_line": current_chunk_sections[0]["start_line"],
+                "end_line": current_chunk_sections[-1]["end_line"],
+            }
+        )
+
+    return suggestions

adversarial_workflow/utils/validation.py

@@ -47,7 +47,9 @@ def validate_evaluation_output(
         "concerns",
     ]
 
-    has_evaluation_content = any(marker in content_lower for marker in evaluation_markers)
+    has_evaluation_content = any(
+        marker in content_lower for marker in evaluation_markers
+    )
     if not has_evaluation_content:
         return (
             False,

{adversarial_workflow-0.6.1.dist-info → adversarial_workflow-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adversarial-workflow
-Version: 0.6.1
+Version: 0.6.3
 Summary: Multi-stage AI code review system preventing phantom work - Author/Evaluator pattern
 Author: Fredrik Matheson
 License: MIT
@@ -55,9 +55,30 @@ Evaluate proposals, sort out ideas, and prevent "phantom work" (AI claiming to i
 - 🎯 **Tool-agnostic**: Use with Claude Code, Cursor, Aider, manual coding, or any workflow
 - ✨ **Interactive onboarding**: Guided setup wizard gets you started in <5 minutes
 
-## What's New in v0.6.0
+## What's New in v0.6.3
 
-🔌 **Plugin Architecture** - Define custom evaluators without modifying the package:
+### Upgrade
+
+```bash
+pip install --upgrade adversarial-workflow
+```
+
+### v0.6.3 - Configurable Timeouts
+
+- **Per-evaluator timeout**: Add `timeout: 300` to evaluator YAML for slow models like Mistral Large
+- **CLI override**: Use `--timeout 400` to override YAML config on-the-fly
+- **Timeout logging**: See which timeout source is used (CLI/YAML/default)
+- **Safety limits**: Maximum 600 seconds to prevent runaway processes
+
+### v0.6.2 - .env Loading & Stability
+
+- **Automatic .env loading**: API keys in `.env` files are now loaded at CLI startup
+- **Custom evaluator support**: Evaluators using `api_key_env: GEMINI_API_KEY` (or other keys) now work with `.env` files
+- **Better diagnostics**: `adversarial check` correctly reports the number of variables loaded from `.env`
+
+### v0.6.0 - Plugin Architecture
+
+🔌 **Custom Evaluators** - Define your own evaluators without modifying the package:
 
 ```bash
 # Create a custom evaluator
@@ -459,6 +480,7 @@ Starting with v0.6.0, you can define project-specific evaluators without modifyi
 | `aliases` | No | Alternative command names |
 | `log_prefix` | No | CLI output prefix |
 | `fallback_model` | No | Fallback model if primary fails |
+| `timeout` | No | Timeout in seconds (default: 180, max: 600) |
 | `version` | No | Evaluator version (default: 1.0.0) |
 
 ### Listing Available Evaluators

{adversarial_workflow-0.6.1.dist-info → adversarial_workflow-0.6.3.dist-info}/RECORD

@@ -1,11 +1,11 @@
-adversarial_workflow/__init__.py,sha256=0AhyTbjRHXfTskqMpd272ayiGdU4rfQqAcf9_oJScnA,596
-adversarial_workflow/__main__.py,sha256=Ibb0CngDCh4mpCe8Zxnf3kyKnMddBxQy2JAk_kfTUMQ,119
-adversarial_workflow/cli.py,sha256=ckrJNqJiX6Okg5f7UcahaB2-qx8PrnQg5MA6OymKrpY,110065
-adversarial_workflow/evaluators/__init__.py,sha256=vB4gGaoP46a-ZLOeoVKjR6WohAsgeif4JMhaak9AIPo,1266
+adversarial_workflow/__init__.py,sha256=moTEp6nKU5F4B1YnJaSBmwhptkDP0ST5n--2hak9PRc,596
+adversarial_workflow/__main__.py,sha256=iM2jmO5YCFpGxfWiEhIYi_SsxVa0hRIE-MB7J0EcN7Y,120
+adversarial_workflow/cli.py,sha256=FxjoC3KVUiwbOF7mWNPe6Zrk82fQcqyE8SPi5bo3ntI,111802
+adversarial_workflow/evaluators/__init__.py,sha256=A9ZKUmjSMfyvEu6jDzYAFLxfkt_OQ4RGA10Bv_eO2i4,1267
 adversarial_workflow/evaluators/builtins.py,sha256=u5LokYLe8ruEW2tunhOQaNSkpcZ9Ee2IeTkaC0dZDSY,1102
-adversarial_workflow/evaluators/config.py,sha256=05qYPIiIpCxXBVJzs70WQQLxi8I7MedfhE_oydXEcq0,1520
-adversarial_workflow/evaluators/discovery.py,sha256=V5vyFLKfh3Q9MVEipWMdD0tzsW3xC3RttVS_oEeWIb8,6801
-adversarial_workflow/evaluators/runner.py,sha256=27fdz49wdkNyBfdjr9VcZZA53rw270XYQWp_2y5s0PU,9244
+adversarial_workflow/evaluators/config.py,sha256=H_4vkto07rAqnz0qEYdzN_DH6WbvRPMIEdkEOFE58UI,1651
+adversarial_workflow/evaluators/discovery.py,sha256=dPQ0dDy9anYjzLnG-V9gVrLkCVAVZ2tEE9dyFWqSvJc,8079
+adversarial_workflow/evaluators/runner.py,sha256=JPVeigjGF2fRDVJLcGyDEuy9pCIp-LjmVAZyucMbdCU,9310
 adversarial_workflow/templates/.aider.conf.yml.template,sha256=jT2jWIgsnmS3HLhoQWMTO3GV07bUcsT2keYw60jqiDw,183
 adversarial_workflow/templates/.env.example.template,sha256=TmTlcgz44uZqIbqgXqdfHMl-0vVn96F_EGNohClFkb8,1821
 adversarial_workflow/templates/README.template,sha256=FQAMPO99eIt_kgQfwhGHcrK736rm_MEvWSbPnqBSjAE,1349
@@ -23,11 +23,11 @@ adversarial_workflow/templates/agent-context/current-state.json.template,sha256=
 adversarial_workflow/utils/__init__.py,sha256=Pnm-a_jqoMVOxHdvVWXeVrL0IKI-zkY7EAdbQmZAkSI,352
 adversarial_workflow/utils/colors.py,sha256=uRrG6KfIDBLo0F5_vPwms9NCm9-x8YXBiyZ4naCr868,160
 adversarial_workflow/utils/config.py,sha256=NBoC_-YYukEVo6BgpX2cDyeqV-3tnn_sHNU9L1AuSLQ,1341
-adversarial_workflow/utils/file_splitter.py,sha256=rVRMHJgzJ7uNiytimqbBY8PAr-SevXdRqUpr4xf6LdM,12061
-adversarial_workflow/utils/validation.py,sha256=0QfuRd-kurcadUCd9XQvO-N8RsmLp6ONQnc0vaQTUBA,2188
-adversarial_workflow-0.6.1.dist-info/licenses/LICENSE,sha256=M-dOQlre-NmicyPa55hYOJUW8roGpCKEgtq-z0z1KCA,1073
-adversarial_workflow-0.6.1.dist-info/METADATA,sha256=ItR4yn7PWdP_AsFqDLMQhAkwuxhit76LxkQYHsVDXlo,29955
-adversarial_workflow-0.6.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-adversarial_workflow-0.6.1.dist-info/entry_points.txt,sha256=9H-iZ-yF1uKZ8P0G1suc6kWR0NvK7uPZJbhN7nvt1sE,62
-adversarial_workflow-0.6.1.dist-info/top_level.txt,sha256=8irutNxLRjUbTlzfAibIpz7_ovkkF2h8ES69NQpv24c,21
-adversarial_workflow-0.6.1.dist-info/RECORD,,
+adversarial_workflow/utils/file_splitter.py,sha256=-zSWgAZ71DfX6dBu15Y4M84NBbJzq-0ENktbBEp9zvQ,12409
+adversarial_workflow/utils/validation.py,sha256=ZiJxtm03kJXicfFTt0QZwpc9V_D8PkDOVYrJEDsafQI,2202
+adversarial_workflow-0.6.3.dist-info/licenses/LICENSE,sha256=M-dOQlre-NmicyPa55hYOJUW8roGpCKEgtq-z0z1KCA,1073
+adversarial_workflow-0.6.3.dist-info/METADATA,sha256=4dfW8_CURJEoooPFtdqtYu-R-BVj-SCC-AXg_teHklg,30835
+adversarial_workflow-0.6.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+adversarial_workflow-0.6.3.dist-info/entry_points.txt,sha256=9H-iZ-yF1uKZ8P0G1suc6kWR0NvK7uPZJbhN7nvt1sE,62
+adversarial_workflow-0.6.3.dist-info/top_level.txt,sha256=8irutNxLRjUbTlzfAibIpz7_ovkkF2h8ES69NQpv24c,21
+adversarial_workflow-0.6.3.dist-info/RECORD,,

{adversarial_workflow-0.6.1.dist-info → adversarial_workflow-0.6.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any