adversarial-workflow 0.6.6__tar.gz → 0.7.0__tar.gz

{adversarial_workflow-0.6.6 → adversarial_workflow-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adversarial-workflow
-Version: 0.6.6
+Version: 0.7.0
 Summary: Multi-stage AI evaluation system for task plans, code review, and test validation
 Author: Fredrik Matheson
 License: MIT
@@ -24,9 +24,11 @@ License-File: LICENSE
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: aider-chat>=0.86.0
+Requires-Dist: aiohttp>=3.8.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
 Requires-Dist: black>=22.0; extra == "dev"
 Requires-Dist: isort>=5.0; extra == "dev"
 Requires-Dist: flake8>=4.0; extra == "dev"

{adversarial_workflow-0.6.6 → adversarial_workflow-0.7.0}/adversarial_workflow/__init__.py

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

{adversarial_workflow-0.6.6 → adversarial_workflow-0.7.0}/adversarial_workflow/cli.py

@@ -13,6 +13,7 @@ Commands:
     review - Run Phase 3: Code review
     validate - Run Phase 4: Test validation
     split - Split large task files into smaller evaluable chunks
+    check-citations - Verify URLs in documents before evaluation
 """
 
 import argparse
@@ -29,7 +30,7 @@ from typing import Dict, List, Optional, Tuple
 import yaml
 from dotenv import dotenv_values, load_dotenv
 
-__version__ = "0.6.6"
+__version__ = "0.7.0"
 
 # ANSI color codes for better output
 RESET = "\033[0m"
@@ -2819,6 +2820,106 @@ def list_evaluators() -> int:
     return 0
 
 
+def check_citations(
+    file_path: str,
+    output_tasks: Optional[str] = None,
+    mark_inline: bool = False,
+    concurrency: int = 10,
+    timeout: int = 10,
+) -> int:
+    """
+    Check citations (URLs) in a document.
+
+    Args:
+        file_path: Path to document to check
+        output_tasks: Optional path to write blocked URL tasks
+        mark_inline: Whether to mark URLs inline with status badges
+        concurrency: Maximum concurrent URL checks
+        timeout: Timeout per URL in seconds
+
+    Returns:
+        0 on success, 1 on error
+    """
+    from adversarial_workflow.utils.citations import (
+        URLStatus,
+        check_urls,
+        extract_urls,
+        generate_blocked_tasks,
+        mark_urls_inline,
+        print_verification_summary,
+    )
+
+    # Check file exists
+    if not os.path.exists(file_path):
+        print(f"{RED}Error: File not found: {file_path}{RESET}")
+        return 1
+
+    # Validate parameters
+    if concurrency < 1:
+        print(f"{RED}Error: Concurrency must be at least 1, got {concurrency}{RESET}")
+        return 1
+    if timeout < 1:
+        print(f"{RED}Error: Timeout must be at least 1 second, got {timeout}{RESET}")
+        return 1
+
+    print(f"🔗 Checking citations in: {file_path}")
+    print()
+
+    # Read document
+    with open(file_path, encoding="utf-8") as f:
+        document = f.read()
+
+    # Extract URLs
+    extracted = extract_urls(document)
+    urls = [e.url for e in extracted]
+
+    if not urls:
+        print(f"{YELLOW}No URLs found in document.{RESET}")
+        return 0
+
+    print(f"   Found {len(urls)} URLs to check")
+    print(f"   Checking with concurrency={concurrency}, timeout={timeout}s...")
+    print()
+
+    # Check URLs
+    results = check_urls(
+        urls,
+        concurrency=concurrency,
+        timeout=timeout,
+    )
+
+    # Print summary
+    print_verification_summary(results)
+
+    # Count blocked/broken
+    blocked_count = sum(1 for r in results if r.status in (URLStatus.BLOCKED, URLStatus.BROKEN))
+
+    # Mark document inline if requested
+    if mark_inline and results:
+        marked_document = mark_urls_inline(document, results)
+        if marked_document != document:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(marked_document)
+            print("\n   ✅ Updated document with status badges")
+
+    # Generate blocked tasks if requested or if there are blocked URLs
+    if blocked_count > 0:
+        if output_tasks:
+            output_path = Path(output_tasks)
+        else:
+            # Default to .adversarial/blocked-citations/
+            output_dir = Path.cwd() / ".adversarial" / "blocked-citations"
+            output_dir.mkdir(parents=True, exist_ok=True)
+            base_name = Path(file_path).stem
+            output_path = output_dir / f"{base_name}-blocked-urls.md"
+
+        task_content = generate_blocked_tasks(results, file_path, output_path)
+        if task_content:
+            print(f"   📋 Blocked URL tasks: {output_path}")
+
+    return 0
+
+
 def main():
     """Main CLI entry point."""
     import logging
@@ -2862,6 +2963,7 @@ def main():
         "validate",
         "review",
         "list-evaluators",
+        "check-citations",
     }
 
     parser = argparse.ArgumentParser(
@@ -2879,6 +2981,7 @@ Examples:
   adversarial review                    # Review implementation
   adversarial validate "npm test"       # Validate with tests
   adversarial split large-task.md       # Split large files
+  adversarial check-citations doc.md    # Verify URLs in document
 
 For more information: https://github.com/movito/adversarial-workflow
         """,
@@ -2961,6 +3064,38 @@ For more information: https://github.com/movito/adversarial-workflow
         help="List all available evaluators (built-in and local)",
     )
 
+    # check-citations command
+    citations_parser = subparsers.add_parser(
+        "check-citations",
+        help="Verify URLs in a document before evaluation",
+    )
+    citations_parser.add_argument("file", help="Document to check citations in")
+    citations_parser.add_argument(
+        "--output-tasks",
+        "-o",
+        help="Output file for blocked URL tasks (markdown)",
+    )
+    citations_parser.add_argument(
+        "--mark-inline",
+        action="store_true",
+        default=False,
+        help="Mark URLs inline with status badges (modifies document)",
+    )
+    citations_parser.add_argument(
+        "--concurrency",
+        "-c",
+        type=int,
+        default=10,
+        help="Maximum concurrent URL checks (default: 10)",
+    )
+    citations_parser.add_argument(
+        "--timeout",
+        "-t",
+        type=int,
+        default=10,
+        help="Timeout per URL in seconds (default: 10)",
+    )
+
     # Dynamic evaluator registration
     try:
         evaluators = get_all_evaluators()
@@ -3009,6 +3144,11 @@ For more information: https://github.com/movito/adversarial-workflow
             default=None,
             help="Timeout in seconds (default: from evaluator config or 180, max: 600)",
         )
+        eval_parser.add_argument(
+            "--check-citations",
+            action="store_true",
+            help="Verify URLs in document before evaluation",
+        )
         # Store config for later execution
         eval_parser.set_defaults(evaluator_config=config)
 
@@ -3044,6 +3184,16 @@ For more information: https://github.com/movito/adversarial-workflow
         # Log actual timeout and source
         print(f"Using timeout: {timeout}s ({source})")
 
+        # Check citations first if requested (read-only, doesn't modify file)
+        if getattr(args, "check_citations", False):
+            print()
+            result = check_citations(args.file, mark_inline=False)
+            if result != 0:
+                print(
+                    f"{YELLOW}Warning: Citation check had issues, continuing with evaluation...{RESET}"
+                )
+            print()
+
         return run_evaluator(
             args.evaluator_config,
             args.file,
@@ -3083,6 +3233,14 @@ For more information: https://github.com/movito/adversarial-workflow
         )
     elif args.command == "list-evaluators":
         return list_evaluators()
+    elif args.command == "check-citations":
+        return check_citations(
+            args.file,
+            output_tasks=args.output_tasks,
+            mark_inline=args.mark_inline,
+            concurrency=args.concurrency,
+            timeout=args.timeout,
+        )
     else:
         parser.print_help()
         return 1