empathy-framework 3.7.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

scaffolding/cli.py

@@ -0,0 +1,240 @@
+"""CLI for wizard scaffolding.
+
+Usage:
+    python -m scaffolding create my_wizard --domain healthcare
+    python -m scaffolding create my_wizard --methodology tdd --domain finance
+    python -m scaffolding create my_wizard --interactive
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import argparse
+import logging
+import sys
+
+from patterns import get_pattern_registry
+
+from .methodologies.pattern_compose import PatternCompose
+from .methodologies.tdd_first import TDDFirst
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def cmd_create(args):
+    """Create a new wizard using specified methodology.
+
+    Args:
+        args: Command line arguments
+
+    """
+    wizard_name = args.name
+    domain = args.domain or "general"
+    wizard_type = args.type or "domain"
+    methodology = args.methodology or "pattern"
+
+    print(f"\n{'=' * 60}")
+    print(f"Creating Wizard: {wizard_name}")
+    print(f"{'=' * 60}\n")
+    print(f"Domain: {domain}")
+    print(f"Type: {wizard_type}")
+    print(f"Methodology: {methodology}")
+    print()
+
+    # Get pattern recommendations
+    registry = get_pattern_registry()
+    recommended = registry.recommend_for_wizard(
+        wizard_type=wizard_type,
+        domain=domain,
+    )
+
+    print(f"Recommended Patterns ({len(recommended)}):")
+    for i, pattern in enumerate(recommended, 1):
+        print(f"  {i}. {pattern.name} - {pattern.description[:60]}...")
+
+    # Pattern selection
+    if args.patterns:
+        # User provided patterns
+        selected_patterns = args.patterns.split(",")
+    elif args.interactive:
+        # Interactive selection
+        print("\nSelect patterns (comma-separated numbers, or 'all' for all):")
+        selection = input("> ").strip()
+
+        if selection.lower() == "all":
+            selected_patterns = [p.id for p in recommended]
+        else:
+            try:
+                indices = [int(i.strip()) - 1 for i in selection.split(",")]
+                selected_patterns = [recommended[i].id for i in indices]
+            except (ValueError, IndexError):
+                print("Invalid selection. Using all patterns.")
+                selected_patterns = [p.id for p in recommended]
+    else:
+        # Use all recommended
+        selected_patterns = [p.id for p in recommended]
+
+    print(f"\nUsing {len(selected_patterns)} patterns:")
+    for pid in selected_patterns:
+        print(f"  - {pid}")
+
+    # Create wizard using selected methodology
+    print(f"\nCreating wizard with {methodology} methodology...")
+
+    if methodology == "pattern":
+        method = PatternCompose()
+        result = method.create_wizard(
+            name=wizard_name,
+            domain=domain,
+            wizard_type=wizard_type,
+            selected_patterns=selected_patterns,
+        )
+    elif methodology == "tdd":
+        method = TDDFirst()
+        result = method.create_wizard(
+            name=wizard_name,
+            domain=domain,
+            wizard_type=wizard_type,
+            pattern_ids=selected_patterns,
+        )
+    else:
+        print(f"Unknown methodology: {methodology}")
+        sys.exit(1)
+
+    # Display results
+    print(f"\n{'=' * 60}")
+    print("✅ Wizard Created Successfully!")
+    print(f"{'=' * 60}\n")
+
+    print("Generated Files:")
+    for file_path in result["files"]:
+        print(f"  - {file_path}")
+
+    print("\nPatterns Used:")
+    for pattern_name in result.get("patterns", selected_patterns):
+        print(f"  - {pattern_name}")
+
+    print("\nNext Steps:")
+    for step in result["next_steps"]:
+        print(f"  {step}")
+
+    print()
+
+
+def cmd_list_patterns(args):
+    """List available patterns.
+
+    Args:
+        args: Command line arguments
+
+    """
+    registry = get_pattern_registry()
+
+    print(f"\n{'=' * 60}")
+    print("Available Patterns")
+    print(f"{'=' * 60}\n")
+
+    # Group by category
+    from patterns.core import PatternCategory
+
+    for category in PatternCategory:
+        patterns = registry.list_by_category(category)
+        if not patterns:
+            continue
+
+        print(f"{category.value.upper()} ({len(patterns)} patterns):")
+        for pattern in patterns:
+            print(
+                f"  - {pattern.id:25} | {pattern.name:20} | Reusability: {pattern.reusability_score:.2f}"
+            )
+        print()
+
+    stats = registry.get_statistics()
+    print(f"Total: {stats['total_patterns']} patterns")
+    print(f"Average Reusability: {stats['average_reusability']:.2f}")
+    print()
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Wizard Scaffolding for Empathy Framework",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create healthcare wizard (recommended approach)
+  %(prog)s create patient_intake --domain healthcare
+
+  # Create with TDD methodology
+  %(prog)s create my_wizard --methodology tdd --domain finance
+
+  # Interactive pattern selection
+  %(prog)s create my_wizard --interactive --domain legal
+
+  # Specify patterns manually
+  %(prog)s create my_wizard --patterns linear_flow,approval,structured_fields
+
+  # List available patterns
+  %(prog)s list-patterns
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a new wizard")
+    create_parser.add_argument("name", help="Wizard name (e.g., patient_intake)")
+    create_parser.add_argument(
+        "--domain",
+        "-d",
+        help="Domain (e.g., healthcare, finance, legal)",
+    )
+    create_parser.add_argument(
+        "--type",
+        "-t",
+        choices=["domain", "coach", "ai"],
+        help="Wizard type (default: domain)",
+    )
+    create_parser.add_argument(
+        "--methodology",
+        "-m",
+        choices=["pattern", "tdd"],
+        help="Methodology (default: pattern)",
+    )
+    create_parser.add_argument(
+        "--patterns",
+        "-p",
+        help="Comma-separated pattern IDs",
+    )
+    create_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Interactive pattern selection",
+    )
+
+    # List patterns command
+    list_parser = subparsers.add_parser("list-patterns", help="List available patterns")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Execute command
+    if args.command == "create":
+        cmd_create(args)
+    elif args.command == "list-patterns":
+        cmd_list_patterns(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

test_generator/__init__.py

@@ -0,0 +1,38 @@
+"""Risk-Driven Test Generator for Wizard Factory.
+
+Generates comprehensive tests for wizards based on risk analysis and patterns.
+
+Features:
+- Risk-based test prioritization
+- Pattern-driven test generation
+- Jinja2 templates for unit/integration/E2E tests
+- Fixture generation for common patterns
+- CLI integration
+
+Usage:
+    from test_generator import TestGenerator
+
+    generator = TestGenerator()
+    tests = generator.generate_tests(
+        wizard_id="soap_note",
+        pattern_ids=["linear_flow", "approval", "structured_fields"]
+    )
+
+    # Write tests to file
+    with open("test_soap_note.py", "w") as f:
+        f.write(tests["unit"])
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .generator import TestGenerator
+from .risk_analyzer import RiskAnalysis, RiskAnalyzer
+
+__all__ = [
+    "TestGenerator",
+    "RiskAnalyzer",
+    "RiskAnalysis",
+]
+
+__version__ = "1.0.0"

test_generator/__main__.py

@@ -0,0 +1,14 @@
+"""Make test_generator runnable as a module.
+
+Usage:
+    python -m test_generator generate soap_note --patterns linear_flow,approval
+    python -m test_generator analyze debugging --patterns code_analysis_input
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

test_generator/cli.py

@@ -0,0 +1,226 @@
+"""CLI for test generator.
+
+Usage:
+    python -m test_generator.cli generate soap_note --patterns linear_flow,approval,structured_fields
+    python -m test_generator.cli analyze soap_note --patterns linear_flow,approval
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+
+from .generator import TestGenerator
+from .risk_analyzer import RiskAnalyzer
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def cmd_generate(args):
+    """Generate tests for a wizard.
+
+    Args:
+        args: Command line arguments
+
+    """
+    wizard_id = args.wizard_id
+    pattern_ids = args.patterns.split(",") if args.patterns else []
+
+    logger.info(f"Generating tests for wizard: {wizard_id}")
+    logger.info(f"Patterns: {', '.join(pattern_ids)}")
+
+    # Generate tests
+    generator = TestGenerator()
+    tests = generator.generate_tests(
+        wizard_id=wizard_id,
+        pattern_ids=pattern_ids,
+        wizard_module=args.module,
+        wizard_class=args.wizard_class,
+    )
+
+    # Determine output directory
+    output_dir = Path(args.output) if args.output else Path("tests/unit/wizards")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write unit tests
+    unit_test_file = output_dir / f"test_{wizard_id}_wizard.py"
+    with open(unit_test_file, "w") as f:
+        f.write(tests["unit"])
+    logger.info(f"✓ Unit tests written to: {unit_test_file}")
+
+    # Write integration tests (if generated)
+    if tests["integration"]:
+        integration_test_file = (
+            output_dir.parent.parent / "integration" / f"test_{wizard_id}_integration.py"
+        )
+        integration_test_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(integration_test_file, "w") as f:
+            f.write(tests["integration"])
+        logger.info(f"✓ Integration tests written to: {integration_test_file}")
+
+    # Write fixtures
+    fixtures_file = output_dir / f"fixtures_{wizard_id}.py"
+    with open(fixtures_file, "w") as f:
+        f.write(tests["fixtures"])
+    logger.info(f"✓ Fixtures written to: {fixtures_file}")
+
+    print("\n🎉 Test generation complete!")
+    print("\nGenerated files:")
+    print(f"  - {unit_test_file}")
+    if tests["integration"]:
+        print(f"  - {integration_test_file}")
+    print(f"  - {fixtures_file}")
+
+    print("\nNext steps:")
+    print("  1. Review generated tests")
+    print(f"  2. Run tests: pytest {unit_test_file}")
+    print("  3. Add custom test cases as needed")
+
+
+def cmd_analyze(args):
+    """Analyze wizard risk and show recommendations.
+
+    Args:
+        args: Command line arguments
+
+    """
+    wizard_id = args.wizard_id
+    pattern_ids = args.patterns.split(",") if args.patterns else []
+
+    logger.info(f"Analyzing wizard: {wizard_id}")
+
+    # Perform risk analysis
+    analyzer = RiskAnalyzer()
+    analysis = analyzer.analyze(wizard_id, pattern_ids)
+
+    # Display results
+    print(f"\n{'=' * 60}")
+    print(f"Risk Analysis: {wizard_id}")
+    print(f"{'=' * 60}\n")
+
+    print(f"Patterns Used: {len(analysis.pattern_ids)}")
+    for pid in analysis.pattern_ids:
+        print(f"  - {pid}")
+
+    print(f"\nCritical Paths: {len(analysis.critical_paths)}")
+    for path in analysis.critical_paths:
+        print(f"  - {path}")
+
+    print(f"\nHigh-Risk Inputs: {len(analysis.high_risk_inputs)}")
+    for input_risk in analysis.high_risk_inputs[:5]:  # Top 5
+        print(f"  - {input_risk}")
+
+    print(f"\nValidation Points: {len(analysis.validation_points)}")
+    for validation in analysis.validation_points[:5]:  # Top 5
+        print(f"  - {validation}")
+
+    print(f"\n{'=' * 60}")
+    print(f"Recommended Test Coverage: {analysis.recommended_coverage}%")
+    print(f"{'=' * 60}\n")
+
+    print("Test Priorities:")
+    for test_name, priority in sorted(analysis.test_priorities.items(), key=lambda x: x[1])[:10]:
+        priority_label = {
+            1: "CRITICAL",
+            2: "HIGH",
+            3: "MEDIUM",
+            4: "LOW",
+            5: "OPTIONAL",
+        }.get(priority, "UNKNOWN")
+        print(f"  [{priority_label:8}] {test_name}")
+
+    # JSON output if requested
+    if args.json:
+        json_output = analysis.to_dict()
+        json_file = Path(f"{wizard_id}_risk_analysis.json")
+        with open(json_file, "w") as f:
+            json.dump(json_output, f, indent=2)
+        print(f"\n✓ JSON output written to: {json_file}")
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Test Generator for Empathy Wizard Factory",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate tests for SOAP Note wizard
+  %(prog)s generate soap_note --patterns linear_flow,approval,structured_fields
+
+  # Analyze risk for debugging wizard
+  %(prog)s analyze debugging --patterns code_analysis_input,risk_assessment
+
+  # Generate with custom module/class
+  %(prog)s generate my_wizard --patterns linear_flow --module wizards.my_wizard --class MyWizard
+
+  # Output to custom directory
+  %(prog)s generate soap_note --patterns linear_flow --output tests/custom/
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Generate command
+    gen_parser = subparsers.add_parser("generate", help="Generate tests for a wizard")
+    gen_parser.add_argument("wizard_id", help="Wizard identifier (e.g., soap_note)")
+    gen_parser.add_argument(
+        "--patterns",
+        required=True,
+        help="Comma-separated pattern IDs (e.g., linear_flow,approval)",
+    )
+    gen_parser.add_argument(
+        "--module",
+        help="Python module path (e.g., wizards.soap_note)",
+    )
+    gen_parser.add_argument(
+        "--class",
+        dest="wizard_class",
+        help="Wizard class name (e.g., SOAPNoteWizard)",
+    )
+    gen_parser.add_argument(
+        "--output",
+        "-o",
+        help="Output directory (default: tests/unit/wizards/)",
+    )
+
+    # Analyze command
+    analyze_parser = subparsers.add_parser("analyze", help="Analyze wizard risk")
+    analyze_parser.add_argument("wizard_id", help="Wizard identifier")
+    analyze_parser.add_argument(
+        "--patterns",
+        required=True,
+        help="Comma-separated pattern IDs",
+    )
+    analyze_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output JSON file with analysis results",
+    )
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Execute command
+    if args.command == "generate":
+        cmd_generate(args)
+    elif args.command == "analyze":
+        cmd_analyze(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()