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

empathy_software_plugin/cli/inspect.py

@@ -0,0 +1,362 @@
+"""Code Inspection CLI
+
+Command-line interface for the Code Inspection Agent Pipeline.
+
+Usage:
+    empathy-inspect [path] [options]
+
+Examples:
+    empathy-inspect .                    # Inspect current directory
+    empathy-inspect ./src --parallel     # Parallel mode
+    empathy-inspect . --format json      # JSON output
+    empathy-inspect . --staged           # Only staged changes
+    empathy-inspect . --fix              # Auto-fix safe issues
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+
+"""
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+
+async def run_auto_fix(project_path: str, verbose: bool = False) -> int:
+    """Run auto-fix using ruff.
+
+    Args:
+        project_path: Path to project to fix
+        verbose: Whether to show verbose output
+
+    Returns:
+        Number of issues fixed
+
+    """
+    import subprocess
+
+    fixed_count = 0
+
+    # Run ruff check with --fix
+    try:
+        print("\nRunning ruff --fix...")
+        result = subprocess.run(
+            ["ruff", "check", project_path, "--fix", "--exit-zero"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+        if verbose and result.stdout:
+            print(result.stdout)
+
+        # Count fixes from output
+        if "Fixed" in result.stdout:
+            # Parse "Fixed X errors" or similar
+            import re
+
+            match = re.search(r"Fixed (\d+)", result.stdout)
+            if match:
+                fixed_count += int(match.group(1))
+
+    except FileNotFoundError:
+        print("Warning: ruff not found. Install with: pip install ruff")
+    except Exception as e:
+        print(f"Warning: ruff fix failed: {e}")
+
+    # Run ruff format for formatting fixes
+    try:
+        print("Running ruff format...")
+        result = subprocess.run(
+            ["ruff", "format", project_path],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+        if verbose and result.stdout:
+            print(result.stdout)
+
+        # Count formatted files
+        if "file" in result.stderr.lower():
+            import re
+
+            match = re.search(r"(\d+) file", result.stderr)
+            if match:
+                fixed_count += int(match.group(1))
+
+    except FileNotFoundError:
+        pass  # Already warned above
+    except Exception as e:
+        if verbose:
+            print(f"Warning: ruff format failed: {e}")
+
+    # Run isort for import sorting
+    try:
+        print("Running isort...")
+        result = subprocess.run(
+            ["isort", project_path, "--profile", "black"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+        if verbose and result.stdout:
+            print(result.stdout)
+
+        # isort shows "Fixing" for each file
+        if "Fixing" in result.stdout:
+            fixed_count += result.stdout.count("Fixing")
+
+    except FileNotFoundError:
+        if verbose:
+            print("Note: isort not found. Install with: pip install isort")
+    except Exception as e:
+        if verbose:
+            print(f"Warning: isort failed: {e}")
+
+    return fixed_count
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        prog="empathy-inspect",
+        description="Code Inspection Agent Pipeline",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  empathy-inspect .                    Inspect current directory
+  empathy-inspect ./src --parallel     Run static checks in parallel
+  empathy-inspect . --format json      Output as JSON
+  empathy-inspect . --staged           Inspect staged git changes only
+  empathy-inspect . --quick            Quick mode (skip slow checks)
+        """,
+    )
+
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        help="Path to inspect (default: current directory)",
+    )
+
+    parser.add_argument(
+        "--parallel",
+        action="store_true",
+        default=True,
+        help="Run Phase 1 tools in parallel (default: True)",
+    )
+
+    parser.add_argument(
+        "--no-parallel",
+        action="store_true",
+        help="Disable parallel execution",
+    )
+
+    parser.add_argument(
+        "--learning",
+        action="store_true",
+        default=True,
+        help="Enable pattern learning (default: True)",
+    )
+
+    parser.add_argument(
+        "--no-learning",
+        action="store_true",
+        help="Disable pattern learning",
+    )
+
+    parser.add_argument(
+        "--format",
+        "-f",
+        choices=["terminal", "json", "markdown", "sarif", "html"],
+        default="terminal",
+        help="Output format (default: terminal). Use 'sarif' for GitHub Actions.",
+    )
+
+    parser.add_argument(
+        "--staged",
+        action="store_true",
+        help="Only inspect staged git changes",
+    )
+
+    parser.add_argument(
+        "--changed",
+        action="store_true",
+        help="Only inspect changed files (vs HEAD)",
+    )
+
+    parser.add_argument(
+        "--quick",
+        "-q",
+        action="store_true",
+        help="Quick mode (skip slow checks like deep debugging)",
+    )
+
+    parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Auto-fix safe issues (formatting, imports)",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Verbose output",
+    )
+
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        help="Write report to file",
+    )
+
+    parser.add_argument(
+        "--exclude",
+        "-e",
+        type=str,
+        action="append",
+        default=[],
+        help="Glob patterns to exclude (can be used multiple times)",
+    )
+
+    # Baseline/suppression options
+    parser.add_argument(
+        "--no-baseline",
+        action="store_true",
+        help="Disable baseline filtering (show all findings)",
+    )
+
+    parser.add_argument(
+        "--baseline-init",
+        action="store_true",
+        help="Create an empty .empathy-baseline.json file",
+    )
+
+    parser.add_argument(
+        "--baseline-cleanup",
+        action="store_true",
+        help="Remove expired suppressions from baseline",
+    )
+
+    return parser.parse_args()
+
+
+async def run_inspection(args: argparse.Namespace) -> int:
+    """Run the inspection and return exit code."""
+    # Import here to avoid slow startup
+    from agents.code_inspection import CodeInspectionAgent
+
+    # Resolve path
+    project_path = str(Path(args.path).resolve())
+
+    # Determine target mode
+    if args.staged:
+        target_mode = "staged"
+    elif args.changed:
+        target_mode = "changed"
+    else:
+        target_mode = "all"
+
+    # Create agent
+    agent = CodeInspectionAgent(
+        parallel_mode=args.parallel and not args.no_parallel,
+        learning_enabled=args.learning and not args.no_learning,
+        baseline_enabled=not args.no_baseline,
+    )
+
+    # Configure verbose logging
+    if args.verbose:
+        import logging
+
+        logging.basicConfig(level=logging.DEBUG)
+
+    # Run inspection
+    state = await agent.inspect(
+        project_path=project_path,
+        target_mode=target_mode,
+        exclude_patterns=args.exclude if args.exclude else None,
+    )
+
+    # Format report
+    report = agent.format_report(state, args.format)
+
+    # Output
+    if args.output:
+        output_path = Path(args.output)
+        output_path.write_text(report)
+        print(f"Report written to {output_path}")
+    else:
+        print(report)
+
+    # Auto-fix if requested
+    if args.fix:
+        fixed_count = await run_auto_fix(project_path, args.verbose)
+        if fixed_count > 0:
+            print(f"\nAuto-fixed {fixed_count} issues. Run inspection again to verify.")
+
+    # Return exit code based on health status
+    if state["health_status"] == "fail":
+        return 1
+    if state["health_status"] == "warn":
+        return 0  # Warn but don't fail
+    return 0
+
+
+def handle_baseline_commands(args: argparse.Namespace) -> bool:
+    """Handle baseline-specific commands.
+
+    Returns:
+        True if a baseline command was handled (and should exit)
+
+    """
+    from agents.code_inspection.baseline import BaselineManager, create_baseline_file
+
+    project_path = str(Path(args.path).resolve())
+
+    if args.baseline_init:
+        baseline_path = create_baseline_file(project_path)
+        print(f"Created baseline file: {baseline_path}")
+        return True
+
+    if args.baseline_cleanup:
+        manager = BaselineManager(project_path)
+        if manager.load():
+            removed = manager.cleanup_expired()
+            print(f"Removed {removed} expired suppressions")
+        else:
+            print("No baseline file found")
+        return True
+
+    return False
+
+
+def main():
+    """Main entry point for CLI."""
+    args = parse_args()
+
+    try:
+        # Handle baseline commands first
+        if handle_baseline_commands(args):
+            sys.exit(0)
+
+        exit_code = asyncio.run(run_inspection(args))
+        sys.exit(exit_code)
+    except KeyboardInterrupt:
+        print("\nInspection cancelled.")
+        sys.exit(130)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

empathy_software_plugin/cli.py

@@ -1,5 +1,4 @@
-"""
-Empathy Framework - Software Development CLI
+"""Empathy Framework - Software Development CLI
 
 Command-line interface for running AI development wizards on your codebase.
 
@@ -98,14 +97,14 @@ async def analyze_project(
     output_format: str = "text",
     verbose: bool = False,
 ):
-    """
-    Analyze a project with AI development wizards.
+    """Analyze a project with AI development wizards.
 
     Args:
         project_path: Path to project root
         wizard_names: List of wizard names to run (or None for all)
         output_format: 'text' or 'json'
         verbose: Show detailed output
+
     """
     logger.info(f"Starting project analysis for: {project_path} (format: {output_format})")
     print_header("Empathy Framework - AI Development Analysis")
@@ -192,8 +191,7 @@ async def analyze_project(
 
 
 async def gather_project_context(project_path: str) -> dict[str, Any]:
-    """
-    Gather context about the project.
+    """Gather context about the project.
 
     Returns dictionary with all context needed by wizards.
     """
@@ -234,8 +232,10 @@ async def gather_project_context(project_path: str) -> dict[str, Any]:
 
                             # Parse AI calls
                             context["ai_calls"].extend(parse_ai_calls(str(file_path), content))
-                except Exception:
-                    pass  # Skip files that can't be parsed
+                except Exception as e:
+                    # Best effort: Skip files that can't be parsed (corrupted, binary, etc.)
+                    logger.debug(f"Could not parse {file_path}: {e}")
+                    pass
 
                 # All Python/JS/TS files are code files
                 context["code_files"].append(str(file_path))
@@ -264,6 +264,7 @@ async def gather_project_context(project_path: str) -> dict[str, Any]:
 
         result = subprocess.run(
             ["git", "log", "--oneline", "--name-only", "-50"],
+            check=False,
             cwd=project_path,
             capture_output=True,
             text=True,
@@ -271,8 +272,10 @@ async def gather_project_context(project_path: str) -> dict[str, Any]:
         )
         if result.returncode == 0:
             context["version_history"] = parse_git_history(result.stdout)
-    except Exception:
-        pass  # Skip if git not available or fails
+    except Exception as e:
+        # Optional: Git history unavailable (not a git repo or git not installed)
+        logger.debug(f"Could not fetch git history: {e}")
+        pass
 
     return context
 
@@ -291,7 +294,7 @@ def parse_ai_calls(file_path: str, content: str) -> list[dict[str, Any]]:
                 "code_snippet": content[:500],  # First 500 chars as sample
                 "prompt_size": len(content),
                 "conversation_id": None,  # Could detect from context
-            }
+            },
         )
 
     return calls
@@ -320,7 +323,6 @@ def parse_git_history(git_output: str) -> list[dict[str, Any]]:
 
 def prepare_wizard_context(wizard_name: str, full_context: dict[str, Any]) -> dict[str, Any]:
     """Prepare context specific to a wizard's requirements"""
-
     base_context = {
         "project_path": full_context["project_path"],
         "version_history": full_context.get("version_history", []),
@@ -332,7 +334,7 @@ def prepare_wizard_context(wizard_name: str, full_context: dict[str, Any]) -> di
             "prompt_files": full_context.get("prompt_files", []),
         }
 
-    elif wizard_name == "context_window":
+    if wizard_name == "context_window":
         return {
             **base_context,
             "ai_calls": full_context.get("ai_calls", []),
@@ -341,14 +343,14 @@ def prepare_wizard_context(wizard_name: str, full_context: dict[str, Any]) -> di
             "model_name": "claude-3-sonnet",
         }
 
-    elif wizard_name == "collaboration_pattern":
+    if wizard_name == "collaboration_pattern":
         return {
             **base_context,
             "ai_integration_files": full_context.get("ai_integration_files", []),
             "ai_usage_patterns": full_context.get("ai_usage_patterns", []),
         }
 
-    elif wizard_name == "ai_documentation":
+    if wizard_name == "ai_documentation":
         return {
             **base_context,
             "documentation_files": full_context.get("documentation_files", []),
@@ -360,7 +362,6 @@ def prepare_wizard_context(wizard_name: str, full_context: dict[str, Any]) -> di
 
 def display_wizard_results(wizard, result: dict[str, Any], verbose: bool):
     """Display wizard results in human-readable format"""
-
     # Issues
     issues = result.get("issues", [])
     if issues:
@@ -461,7 +462,7 @@ def list_wizards():
             print(f"\n{Colors.BOLD}{wizard_id}{Colors.END}")
             print(f"  Name: {info['name']}")
             print(
-                f"  Level: {info['empathy_level']} ({'Anticipatory' if info['empathy_level'] == 4 else 'Other'})"
+                f"  Level: {info['empathy_level']} ({'Anticipatory' if info['empathy_level'] == 4 else 'Other'})",
             )
             print(f"  Category: {info.get('category', 'N/A')}")
 
@@ -520,10 +521,15 @@ Examples:
     analyze_parser = subparsers.add_parser("analyze", help="Analyze a project")
     analyze_parser.add_argument("path", help="Path to project")
     analyze_parser.add_argument(
-        "--wizards", help="Comma-separated list of wizards to run", default=None
+        "--wizards",
+        help="Comma-separated list of wizards to run",
+        default=None,
     )
     analyze_parser.add_argument(
-        "--output", choices=["text", "json"], default="text", help="Output format"
+        "--output",
+        choices=["text", "json"],
+        default="text",
+        help="Output format",
     )
     analyze_parser.add_argument("--verbose", action="store_true", help="Show detailed output")
 
@@ -552,21 +558,20 @@ Examples:
                 wizard_names=wizard_names,
                 output_format=args.output,
                 verbose=args.verbose,
-            )
+            ),
         )
 
-    elif args.command == "list-wizards":
+    if args.command == "list-wizards":
         return list_wizards()
 
-    elif args.command == "wizard-info":
+    if args.command == "wizard-info":
         return wizard_info(args.wizard_id)
 
     return 0
 
 
 def scan_command():
-    """
-    Entry point for empathy-scan command (converted from bin/empathy-scan).
+    """Entry point for empathy-scan command (converted from bin/empathy-scan).
     One-click security & performance scanner.
     """
     logger.info("Empathy Framework security and performance scanner started")
@@ -646,7 +651,9 @@ def scan_command():
 
         for wizard_name, wizard in wizards:
             result = wizard.run_full_analysis(
-                code=code, file_path=str(file_path), language="python"
+                code=code,
+                file_path=str(file_path),
+                language="python",
             )
 
             if result.issues:
@@ -655,7 +662,9 @@ def scan_command():
                     severity_icon = (
                         "🔴"
                         if issue.severity == "high"
-                        else "🟡" if issue.severity == "medium" else "🔵"
+                        else "🟡"
+                        if issue.severity == "medium"
+                        else "🔵"
                     )
                     print(f"    {severity_icon} Line {issue.line_number}: {issue.message}")
                 if len(result.issues) > 3:

empathy_software_plugin/plugin.py

@@ -1,5 +1,4 @@
-"""
-Software Development Plugin for Empathy Framework
+"""Software Development Plugin for Empathy Framework
 
 This plugin provides 16+ Coach wizards for code analysis,
 demonstrating Level 4 Anticipatory Empathy in software development.
@@ -25,8 +24,7 @@ logger = logging.getLogger(__name__)
 
 
 class SoftwarePlugin(BasePlugin):
-    """
-    Software Development Domain Plugin
+    """Software Development Domain Plugin
 
     Provides wizards for:
     - Security analysis
@@ -59,8 +57,7 @@ class SoftwarePlugin(BasePlugin):
         )
 
     def register_wizards(self) -> dict[str, type[BaseWizard]]:
-        """
-        Register all software development wizards.
+        """Register all software development wizards.
 
         In our experience building these wizards, we found that the framework
         enables a fundamental shift: instead of reactive debugging, the system
@@ -157,8 +154,7 @@ class SoftwarePlugin(BasePlugin):
         return wizards
 
     def register_patterns(self) -> dict:
-        """
-        Register software development patterns.
+        """Register software development patterns.
 
         These patterns were learned from real-world usage and enable
         cross-domain learning (Level 5 Systems Empathy).

empathy_software_plugin/wizards/__init__.py

@@ -0,0 +1,42 @@
+"""Software Development Wizards
+
+Production-ready wizards for software development with memory enhancement.
+
+Memory-Enhanced Wizards (Level 4+):
+- MemoryEnhancedDebuggingWizard: Bug correlation with historical patterns
+- TechDebtWizard: Tech debt trajectory tracking and prediction
+- SecurityLearningWizard: Security scanning with false positive learning
+
+Utility Wizards:
+- PatternRetrieverWizard: Pattern search and retrieval (Level 3)
+- PatternExtractionWizard: Auto-detect fixes and suggest patterns (Level 3)
+- CodeReviewWizard: Pattern-based code review (Level 4)
+
+Core Wizards:
+- SecurityAnalysisWizard: OWASP vulnerability detection
+- AdvancedDebuggingWizard: Protocol-based debugging
+- PerformanceProfilingWizard: Performance analysis
+- TestingWizard: Test coverage and quality
+- AIDocumentationWizard: Documentation generation
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .base_wizard import BaseWizard
+from .code_review_wizard import CodeReviewWizard
+from .memory_enhanced_debugging_wizard import MemoryEnhancedDebuggingWizard
+from .pattern_extraction_wizard import PatternExtractionWizard
+from .pattern_retriever_wizard import PatternRetrieverWizard
+from .security_learning_wizard import SecurityLearningWizard
+from .tech_debt_wizard import TechDebtWizard
+
+__all__ = [
+    "BaseWizard",
+    "CodeReviewWizard",
+    "MemoryEnhancedDebuggingWizard",
+    "PatternExtractionWizard",
+    "PatternRetrieverWizard",
+    "SecurityLearningWizard",
+    "TechDebtWizard",
+]