empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/wizard_factory_cli.py

@@ -0,0 +1,170 @@
+"""Wizard Factory CLI integration for Empathy Framework.
+
+Provides wizard-factory commands integrated into the main empathy CLI:
+- empathy wizard-factory create
+- empathy wizard-factory list-patterns
+- empathy wizard-factory generate-tests
+- empathy wizard-factory analyze
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import subprocess
+import sys
+
+
+def cmd_wizard_factory_create(args):
+    """Create a new wizard using scaffolding."""
+    # Build command
+    cmd = ["python", "-m", "scaffolding", "create", args.name]
+
+    if args.domain:
+        cmd.extend(["--domain", args.domain])
+
+    if args.type:
+        cmd.extend(["--type", args.type])
+
+    if args.methodology:
+        cmd.extend(["--methodology", args.methodology])
+
+    if args.patterns:
+        cmd.extend(["--patterns", args.patterns])
+
+    if args.interactive:
+        cmd.append("--interactive")
+
+    # Run scaffolding
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)
+
+
+def cmd_wizard_factory_list_patterns(args):
+    """List available patterns."""
+    result = subprocess.run(["python", "-m", "scaffolding", "list-patterns"])
+    sys.exit(result.returncode)
+
+
+def cmd_wizard_factory_generate_tests(args):
+    """Generate tests for a wizard."""
+    cmd = ["python", "-m", "test_generator", "generate", args.wizard_id]
+
+    if args.patterns:
+        cmd.extend(["--patterns", args.patterns])
+
+    if args.output:
+        cmd.extend(["--output", args.output])
+
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)
+
+
+def cmd_wizard_factory_analyze(args):
+    """Analyze wizard risk."""
+    cmd = ["python", "-m", "test_generator", "analyze", args.wizard_id]
+
+    if args.patterns:
+        cmd.extend(["--patterns", args.patterns])
+
+    if args.json:
+        cmd.append("--json")
+
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)
+
+
+def add_wizard_factory_commands(subparsers):
+    """Add wizard-factory commands to main CLI.
+
+    Args:
+        subparsers: ArgumentParser subparsers object
+    """
+    # Main wizard-factory command
+    parser_wf = subparsers.add_parser(
+        "wizard-factory",
+        help="Wizard Factory - create wizards 12x faster",
+    )
+    wf_subparsers = parser_wf.add_subparsers(dest="wizard_factory_command")
+
+    # wizard-factory create
+    parser_wf_create = wf_subparsers.add_parser(
+        "create",
+        help="Create a new wizard",
+    )
+    parser_wf_create.add_argument("name", help="Wizard name (snake_case)")
+    parser_wf_create.add_argument(
+        "--domain",
+        "-d",
+        help="Domain (healthcare, finance, software, legal, etc.)",
+    )
+    parser_wf_create.add_argument(
+        "--type",
+        "-t",
+        choices=["domain", "coach", "ai"],
+        default="domain",
+        help="Wizard type (default: domain)",
+    )
+    parser_wf_create.add_argument(
+        "--methodology",
+        "-m",
+        choices=["pattern", "tdd"],
+        default="pattern",
+        help="Methodology (pattern-compose or tdd-first, default: pattern)",
+    )
+    parser_wf_create.add_argument(
+        "--patterns",
+        "-p",
+        help="Comma-separated pattern IDs (e.g. linear_flow,approval)",
+    )
+    parser_wf_create.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Interactive pattern selection",
+    )
+    parser_wf_create.set_defaults(func=cmd_wizard_factory_create)
+
+    # wizard-factory list-patterns
+    parser_wf_list = wf_subparsers.add_parser(
+        "list-patterns",
+        help="List available patterns",
+    )
+    parser_wf_list.set_defaults(func=cmd_wizard_factory_list_patterns)
+
+    # wizard-factory generate-tests
+    parser_wf_gen = wf_subparsers.add_parser(
+        "generate-tests",
+        help="Generate tests for a wizard",
+    )
+    parser_wf_gen.add_argument("wizard_id", help="Wizard ID")
+    parser_wf_gen.add_argument(
+        "--patterns",
+        "-p",
+        required=True,
+        help="Comma-separated pattern IDs",
+    )
+    parser_wf_gen.add_argument(
+        "--output",
+        "-o",
+        help="Output directory for tests",
+    )
+    parser_wf_gen.set_defaults(func=cmd_wizard_factory_generate_tests)
+
+    # wizard-factory analyze
+    parser_wf_analyze = wf_subparsers.add_parser(
+        "analyze",
+        help="Analyze wizard risk and get coverage recommendations",
+    )
+    parser_wf_analyze.add_argument("wizard_id", help="Wizard ID")
+    parser_wf_analyze.add_argument(
+        "--patterns",
+        "-p",
+        required=True,
+        help="Comma-separated pattern IDs",
+    )
+    parser_wf_analyze.add_argument(
+        "--json",
+        action="store_true",
+        help="Output JSON format",
+    )
+    parser_wf_analyze.set_defaults(func=cmd_wizard_factory_analyze)

empathy_os/{workflows.py → workflow_commands.py}

@@ -1,5 +1,4 @@
-"""
-One-Command Workflows for Empathy Framework
+"""One-Command Workflows for Empathy Framework
 
 Power-user commands that automate common developer workflows:
 - morning: Start-of-day briefing with patterns, debt, and focus areas
@@ -15,21 +14,22 @@ import json
 import subprocess
 from datetime import datetime, timedelta
 from pathlib import Path
+from typing import Any
 
 from empathy_os.logging_config import get_logger
 
 logger = get_logger(__name__)
 
 
-def _load_patterns(patterns_dir: str = "./patterns") -> dict:
+def _load_patterns(patterns_dir: str = "./patterns") -> dict[str, list]:
     """Load patterns from the patterns directory."""
-    patterns = {"debugging": [], "security": [], "tech_debt": [], "inspection": []}
+    patterns: dict[str, list] = {"debugging": [], "security": [], "tech_debt": [], "inspection": []}
 
     patterns_path = Path(patterns_dir)
     if not patterns_path.exists():
         return patterns
 
-    for pattern_type in patterns.keys():
+    for pattern_type in patterns:
         file_path = patterns_path / f"{pattern_type}.json"
         if file_path.exists():
             try:
@@ -42,13 +42,14 @@ def _load_patterns(patterns_dir: str = "./patterns") -> dict:
     return patterns
 
 
-def _load_stats(empathy_dir: str = ".empathy") -> dict:
+def _load_stats(empathy_dir: str = ".empathy") -> dict[str, Any]:
     """Load usage statistics."""
     stats_file = Path(empathy_dir) / "stats.json"
     if stats_file.exists():
         try:
             with open(stats_file) as f:
-                return json.load(f)
+                result: dict[str, Any] = json.load(f)
+                return result
         except (OSError, json.JSONDecodeError):
             pass
     return {"commands": {}, "last_session": None, "patterns_learned": 0}
@@ -66,7 +67,7 @@ def _save_stats(stats: dict, empathy_dir: str = ".empathy") -> None:
 def _run_command(cmd: list, capture: bool = True) -> tuple:
     """Run a shell command and return (success, output)."""
     try:
-        result = subprocess.run(cmd, capture_output=capture, text=True, timeout=300)
+        result = subprocess.run(cmd, check=False, capture_output=capture, text=True, timeout=300)
         return result.returncode == 0, result.stdout + result.stderr
     except subprocess.TimeoutExpired:
         return False, "Command timed out"
@@ -95,19 +96,19 @@ def _get_tech_debt_trend(patterns_dir: str = "./patterns") -> str:
 
         if recent > previous:
             return "increasing"
-        elif recent < previous:
+        if recent < previous:
             return "decreasing"
-        else:
-            return "stable"
+        return "stable"
     except (OSError, json.JSONDecodeError, KeyError):
         return "unknown"
 
 
 def morning_workflow(
-    patterns_dir: str = "./patterns", project_root: str = ".", verbose: bool = False
+    patterns_dir: str = "./patterns",
+    project_root: str = ".",
+    verbose: bool = False,
 ) -> int:
-    """
-    Start-of-day developer briefing.
+    """Start-of-day developer briefing.
 
     Shows:
     - Health check summary
@@ -154,9 +155,7 @@ def morning_workflow(
     if recent_bugs:
         print(f"\n  New this week: {len(recent_bugs)} patterns")
         for bug in recent_bugs[:3]:
-            print(
-                f"    - {bug.get('bug_type', 'unknown')}: {bug.get('root_cause', 'investigating')[:50]}"
-            )
+            print(f"    - {bug.get('bug_type', '?')}: {bug.get('root_cause', '?')[:40]}")
 
     # 2. Tech debt trajectory
     print("\n" + "TECH DEBT TRAJECTORY")
@@ -231,7 +230,7 @@ def morning_workflow(
     ]
     if investigating_bugs:
         suggestions.append(
-            f"Resolve {len(investigating_bugs)} investigating bug(s) - run 'empathy patterns resolve'"
+            f"Resolve {len(investigating_bugs)} investigating bug(s) via 'empathy patterns resolve'",
         )
 
     if trend == "increasing":
@@ -258,14 +257,93 @@ def morning_workflow(
     return 0
 
 
+def _run_tests_only(project_root: str = ".", verbose: bool = False) -> int:
+    """Run tests only (used by ship --tests-only)."""
+    print("\n" + "=" * 60)
+    print("  TEST RESULTS")
+    print("=" * 60 + "\n")
+
+    # Try pytest first
+    success, output = _run_command(["python", "-m", "pytest", project_root, "-v", "--tb=short"])
+
+    if success:
+        print("All tests passed!")
+        print("\n" + "=" * 60 + "\n")
+        return 0
+    print("Test Results:")
+    print("-" * 40)
+    print(output)
+    print("\n" + "=" * 60 + "\n")
+    return 1
+
+
+def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
+    """Run security checks only (used by ship --security-only)."""
+    print("\n" + "=" * 60)
+    print("  SECURITY SCAN")
+    print("=" * 60 + "\n")
+
+    issues = []
+
+    # Try bandit (Python security scanner)
+    print("1. Running Bandit security scan...")
+    success, output = _run_command(["bandit", "-r", project_root, "-ll", "-q"])
+    if success:
+        print("   PASS - No high/medium security issues")
+    elif "bandit" in output.lower() and "not found" in output.lower():
+        print("   SKIP - Bandit not installed (pip install bandit)")
+    else:
+        issue_count = output.count(">> Issue:")
+        issues.append(f"Bandit: {issue_count} security issues")
+        print(f"   WARN - {issue_count} issues found")
+        if verbose:
+            print(output)
+
+    # Check for secrets in code
+    print("2. Checking for hardcoded secrets...")
+    success, output = _run_command(
+        ["grep", "-rn", "--include=*.py", "password.*=.*['\"]", project_root],
+    )
+    if not success or not output.strip():
+        print("   PASS - No obvious hardcoded secrets")
+    else:
+        lines = len([line for line in output.split("\n") if line.strip()])
+        issues.append(f"Secrets: {lines} potential hardcoded secrets")
+        print(f"   WARN - {lines} potential hardcoded values found")
+
+    # Check for .env files that might be committed
+    print("3. Checking for sensitive files...")
+    success, output = _run_command(["git", "ls-files", ".env", "*.pem", "*.key"])
+    if not output.strip():
+        print("   PASS - No sensitive files tracked")
+    else:
+        files = len([line for line in output.split("\n") if line.strip()])
+        issues.append(f"Files: {files} sensitive files in git")
+        print(f"   WARN - {files} sensitive files tracked in git")
+
+    # Summary
+    print("\n" + "-" * 60)
+    if issues:
+        print("\nSECURITY ISSUES FOUND:")
+        for issue in issues:
+            print(f"  - {issue}")
+        print("\n" + "=" * 60 + "\n")
+        return 1
+
+    print("\nNo security issues found!")
+    print("\n" + "=" * 60 + "\n")
+    return 0
+
+
 def ship_workflow(
     patterns_dir: str = "./patterns",
     project_root: str = ".",
     skip_sync: bool = False,
+    tests_only: bool = False,
+    security_only: bool = False,
     verbose: bool = False,
 ) -> int:
-    """
-    Pre-commit validation pipeline.
+    """Pre-commit validation pipeline.
 
     Runs:
     1. empathy inspect (code analysis)
@@ -273,8 +351,23 @@ def ship_workflow(
     3. empathy sync-claude (pattern sync)
     4. Summary
 
+    Args:
+        patterns_dir: Path to patterns directory
+        project_root: Project root directory
+        skip_sync: Skip syncing patterns to Claude
+        tests_only: Run tests only (skip lint/format checks)
+        security_only: Run security checks only
+        verbose: Show detailed output
+
     Returns exit code (0 = ready to ship, non-zero = issues found).
+
     """
+    if tests_only:
+        return _run_tests_only(project_root, verbose)
+
+    if security_only:
+        return _run_security_only(project_root, verbose)
+
     print("\n" + "=" * 60)
     print("  PRE-SHIP CHECKLIST")
     print("=" * 60 + "\n")
@@ -289,7 +382,7 @@ def ship_workflow(
         print("   PASS - No lint issues")
     else:
         issue_count = len(
-            [line for line in output.split("\n") if line.strip() and not line.startswith("Found")]
+            [line for line in output.split("\n") if line.strip() and not line.startswith("Found")],
         )
         issues.append(f"Lint: {issue_count} issues")
         print(f"   FAIL - {issue_count} issues found")
@@ -307,7 +400,7 @@ def ship_workflow(
                 line
                 for line in output.split("\n")
                 if "would be reformatted" in line.lower() or line.strip().endswith(".py")
-            ]
+            ],
         )
         warnings.append(f"Format: {files} files need formatting")
         print(f"   WARN - {files} files need formatting (run 'empathy fix-all')")
@@ -330,7 +423,7 @@ def ship_workflow(
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
         staged = len(
-            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))]
+            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))],
         )
         unstaged = len([line for line in output.split("\n") if line.startswith((" M", " D", "??"))])
         if staged > 0:
@@ -346,13 +439,14 @@ def ship_workflow(
         print("5. Syncing patterns to Claude Code...")
         # Import here to avoid circular imports
         try:
-            from empathy_llm_toolkit.cli.sync_claude import sync_patterns_to_claude
+            from pathlib import Path
 
-            result = sync_patterns_to_claude(
-                patterns_dir=patterns_dir, output_dir=".claude/rules/empathy"
-            )
-            if result.get("success"):
-                print(f"   PASS - {result.get('patterns_synced', 0)} patterns synced")
+            from empathy_llm_toolkit.cli.sync_claude import sync_patterns
+
+            result = sync_patterns(project_root=Path(), verbose=False)
+            synced_count = len(result.get("synced", []))
+            if synced_count > 0:
+                print(f"   PASS - {synced_count} patterns synced")
             else:
                 print("   SKIP - No patterns to sync")
         except ImportError:
@@ -393,8 +487,7 @@ def ship_workflow(
 
 
 def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bool = False) -> int:
-    """
-    Auto-fix all fixable issues.
+    """Auto-fix all fixable issues.
 
     Runs:
     1. ruff --fix (lint fixes)
@@ -442,7 +535,7 @@ def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bo
                 line
                 for line in output.split("\n")
                 if line.strip().endswith(".py") and "reformatted" in output.lower()
-            ]
+            ],
         )
 
     print(f"   Formatted {formatted} files")
@@ -486,8 +579,7 @@ def learn_workflow(
     watch: bool = False,
     verbose: bool = False,
 ) -> int:
-    """
-    Watch for bug fixes and extract patterns.
+    """Watch for bug fixes and extract patterns.
 
     Modes:
     - analyze: Analyze recent commits for bug fix patterns
@@ -514,7 +606,7 @@ def learn_workflow(
 
     # Get recent commits
     success, output = _run_command(
-        ["git", "log", f"-{commit_count}", "--oneline", "--format=%H|%s|%an|%ai"]
+        ["git", "log", f"-{commit_count}", "--oneline", "--format=%H|%s|%an|%ai"],
     )
 
     if not success:
@@ -594,7 +686,7 @@ def learn_workflow(
 
     # Load existing patterns and merge
     debugging_file = patterns_path / "debugging.json"
-    existing = {"patterns": []}
+    existing: dict[str, Any] = {"patterns": []}
 
     if debugging_file.exists():
         try:
@@ -622,7 +714,7 @@ def learn_workflow(
 
     if learned:
         print("\nBug types discovered:")
-        types = {}
+        types: dict[str, int] = {}
         for p in learned:
             t = p["bug_type"]
             types[t] = types.get(t, 0) + 1
@@ -658,6 +750,8 @@ def cmd_ship(args):
         patterns_dir=getattr(args, "patterns_dir", "./patterns"),
         project_root=getattr(args, "project_root", "."),
         skip_sync=getattr(args, "skip_sync", False),
+        tests_only=getattr(args, "tests_only", False),
+        security_only=getattr(args, "security_only", False),
         verbose=getattr(args, "verbose", False),
     )