empathy-framework 4.7.0__py3-none-any.whl → 4.8.0__py3-none-any.whl

empathy_os/cli/commands/status.py

@@ -0,0 +1,235 @@
+"""Status and health check commands for the CLI.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import asyncio
+
+
+def cmd_status(args):
+    """Session status assistant - prioritized project status report.
+
+    Collects and displays project status including patterns, git context,
+    and health metrics with priority scoring.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - patterns_dir (str): Path to patterns directory (default: ./patterns).
+            - project_root (str): Project root directory (default: .).
+            - inactivity (int): Minutes of inactivity before showing status.
+            - full (bool): If True, show all items without limit.
+            - json (bool): If True, output as JSON format.
+            - select (int | None): Select specific item for action prompt.
+            - force (bool): If True, show status even with recent activity.
+
+    Returns:
+        None: Prints prioritized status report or JSON output.
+    """
+    from empathy_llm_toolkit.session_status import SessionStatusCollector
+
+    config = {"inactivity_minutes": args.inactivity}
+    collector = SessionStatusCollector(
+        patterns_dir=args.patterns_dir,
+        project_root=args.project_root,
+        config=config,
+    )
+
+    # Check if should show (unless forced)
+    if not args.force and not collector.should_show():
+        print("No status update needed (recent activity detected).")
+        print("Use --force to show status anyway.")
+        return
+
+    # Collect status
+    status = collector.collect()
+
+    # Handle selection
+    if args.select:
+        prompt = collector.get_action_prompt(status, args.select)
+        if prompt:
+            print(f"\nAction prompt for selection {args.select}:\n")
+            print(prompt)
+        else:
+            print(f"Invalid selection: {args.select}")
+        return
+
+    # Output
+    if args.json:
+        print(collector.format_json(status))
+    else:
+        max_items = None if args.full else 5
+        print()
+        print(collector.format_output(status, max_items=max_items))
+        print()
+
+    # Record interaction
+    collector.record_interaction()
+
+
+def cmd_review(args):
+    """Pattern-based code review against historical bugs.
+
+    Note: This command has been deprecated. The underlying workflow module
+    has been removed. Use 'empathy workflow run bug-predict' instead.
+
+    Args:
+        args: Namespace object from argparse.
+
+    Returns:
+        None: Prints deprecation message.
+    """
+    print("⚠️  The 'review' command has been deprecated.")
+    print()
+    print("The CodeReviewWorkflow module has been removed.")
+    print("Please use one of these alternatives:")
+    print()
+    print("  empathy workflow run bug-predict    # Scan for risky patterns")
+    print("  ruff check <files>                  # Fast linting")
+    print("  bandit -r <path>                    # Security scanning")
+    print()
+
+
+def cmd_health(args):
+    """Code health assistant - run health checks and auto-fix issues.
+
+    Runs comprehensive health checks including linting, type checking,
+    and formatting with optional auto-fix capability.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - check (str | None): Specific check to run (lint/type/format/test).
+            - deep (bool): If True, run comprehensive checks.
+            - fix (bool): If True, auto-fix issues where possible.
+            - threshold (str): Severity threshold for issues.
+            - project_root (str): Project root directory.
+            - patterns_dir (str): Path to patterns directory.
+            - details (bool): If True, show detailed issue list.
+            - compare (str | None): Compare against historical baseline.
+            - export (str | None): Export results to file.
+            - json (bool): If True, output as JSON format.
+
+    Returns:
+        None: Prints health check results and optionally fixes issues.
+    """
+    from empathy_llm_toolkit.code_health import (
+        AutoFixer,
+        CheckCategory,
+        HealthCheckRunner,
+        HealthTrendTracker,
+        format_health_output,
+    )
+
+    runner = HealthCheckRunner(
+        project_root=args.project_root,
+    )
+
+    # Determine what checks to run
+    if args.check:
+        # Run specific check
+        try:
+            category = CheckCategory(args.check)
+            report_future = runner.run_check(category)
+            result = asyncio.run(report_future)
+            # Create a minimal report with just this result
+            from empathy_llm_toolkit.code_health import HealthReport
+
+            report = HealthReport(project_root=args.project_root)
+            report.add_result(result)
+        except ValueError:
+            print(f"Unknown check category: {args.check}")
+            print(f"Available: {', '.join(c.value for c in CheckCategory)}")
+            return
+    elif args.deep:
+        # Run all checks
+        print("Running comprehensive health check...\n")
+        report = asyncio.run(runner.run_all())
+    else:
+        # Run quick checks (default)
+        report = asyncio.run(runner.run_quick())
+
+    # Handle fix mode
+    if args.fix:
+        fixer = AutoFixer()
+
+        if args.dry_run:
+            # Preview only
+            fixes = fixer.preview_fixes(report)
+            if fixes:
+                print("Would fix the following issues:\n")
+                for fix in fixes:
+                    safe_indicator = " (safe)" if fix["safe"] else " (needs confirmation)"
+                    print(f"  [{fix['category']}] {fix['file']}")
+                    print(f"    {fix['issue']}")
+                    print(f"    Command: {fix['fix_command']}{safe_indicator}")
+                    print()
+            else:
+                print("No auto-fixable issues found.")
+            return
+
+        # Apply fixes
+        if args.check:
+            try:
+                category = CheckCategory(args.check)
+                result = asyncio.run(fixer.fix_category(report, category))
+            except ValueError:
+                result = {"fixed": [], "skipped": [], "failed": []}
+        else:
+            result = asyncio.run(fixer.fix_all(report, interactive=args.interactive))
+
+        # Report fix results
+        if result["fixed"]:
+            print(f"✓ Fixed {len(result['fixed'])} issue(s)")
+            for fix in result["fixed"][:5]:
+                print(f"  - {fix['file_path']}: {fix['message']}")
+            if len(result["fixed"]) > 5:
+                print(f"  ... and {len(result['fixed']) - 5} more")
+
+        if result["skipped"]:
+            if args.interactive:
+                print(f"\n⚠ Skipped {len(result['skipped'])} issue(s) (could not auto-fix)")
+            else:
+                print(
+                    f"\n⚠ Skipped {len(result['skipped'])} issue(s) (use --interactive to review)",
+                )
+
+        if result["failed"]:
+            print(f"\n✗ Failed to fix {len(result['failed'])} issue(s)")
+
+        return
+
+    # Handle trends
+    if args.trends:
+        tracker = HealthTrendTracker(project_root=args.project_root)
+        trends = tracker.get_trends(days=args.trends)
+
+        print(f"📈 Health Trends ({trends['period_days']} days)\n")
+        print(f"Average Score: {trends['average_score']}/100")
+        print(f"Trend: {trends['trend_direction']} ({trends['score_change']:+d})")
+
+        if trends["data_points"]:
+            print("\nRecent scores:")
+            for point in trends["data_points"][:7]:
+                print(f"  {point['date']}: {point['score']}/100")
+
+        hotspots = tracker.identify_hotspots()
+        if hotspots:
+            print("\n🔥 Hotspots (files with recurring issues):")
+            for spot in hotspots[:5]:
+                print(f"  {spot['file']}: {spot['issue_count']} issues")
+
+        return
+
+    # Output report
+    if args.json:
+        import json
+
+        print(json.dumps(report.to_dict(), indent=2, default=str))
+    else:
+        level = 3 if args.full else (2 if args.details else 1)
+        print(format_health_output(report, level=level))
+
+    # Record to trend history
+    if not args.check:  # Only record full runs
+        tracker = HealthTrendTracker(project_root=args.project_root)
+        tracker.record_check(report)

empathy_os/cli/commands/sync.py

@@ -0,0 +1,166 @@
+"""Sync commands for pattern synchronization.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json as json_mod
+from pathlib import Path
+
+from empathy_os.config import _validate_file_path
+from empathy_os.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def cmd_sync_claude(args):
+    """Sync patterns to Claude Code rules directory.
+
+    Converts learned patterns into Claude Code markdown rules.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - patterns_dir (str): Source patterns directory.
+            - output_dir (str): Target Claude Code rules directory.
+
+    Returns:
+        int: 0 on success, 1 on failure.
+
+    Raises:
+        ValueError: If output path is invalid or unsafe.
+    """
+    patterns_dir = Path(args.patterns_dir)
+    # Validate output directory path
+    validated_output_dir = _validate_file_path(args.output_dir)
+    output_dir = validated_output_dir
+
+    print("=" * 60)
+    print("  SYNC PATTERNS TO CLAUDE CODE")
+    print("=" * 60 + "\n")
+
+    if not patterns_dir.exists():
+        print(f"✗ Patterns directory not found: {patterns_dir}")
+        print("  Run 'empathy learn --analyze 20' first to learn patterns")
+        return 1
+
+    # Create output directory
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    synced_count = 0
+    pattern_files = ["debugging.json", "security.json", "tech_debt.json", "inspection.json"]
+
+    for pattern_file in pattern_files:
+        source_path = patterns_dir / pattern_file
+        if not source_path.exists():
+            continue
+
+        try:
+            with open(source_path) as f:
+                data = json_mod.load(f)
+
+            patterns = data.get("patterns", data.get("items", []))
+            if not patterns:
+                continue
+
+            # Generate markdown rule file
+            category = pattern_file.replace(".json", "")
+            rule_content = _generate_claude_rule(category, patterns)
+
+            # Write rule file
+            rule_file = output_dir / f"{category}.md"
+            # Validate rule file path before writing
+            validated_rule_file = _validate_file_path(str(rule_file), allowed_dir=str(output_dir))
+            with open(validated_rule_file, "w") as f:
+                f.write(rule_content)
+
+            print(f"  ✓ {category}: {len(patterns)} patterns → {rule_file}")
+            synced_count += len(patterns)
+
+        except (json_mod.JSONDecodeError, OSError) as e:
+            print(f"  ✗ Failed to process {pattern_file}: {e}")
+
+    print(f"\n{'─' * 60}")
+    print(f"  Total: {synced_count} patterns synced to {output_dir}")
+    print("=" * 60 + "\n")
+
+    if synced_count == 0:
+        print("No patterns to sync. Run 'empathy learn' first.")
+        return 1
+
+    return 0
+
+
+def _generate_claude_rule(category: str, patterns: list) -> str:
+    """Generate a Claude Code rule file from patterns."""
+    lines = [
+        f"# {category.replace('_', ' ').title()} Patterns",
+        "",
+        "Auto-generated from Empathy Framework learned patterns.",
+        f"Total patterns: {len(patterns)}",
+        "",
+        "---",
+        "",
+    ]
+
+    if category == "debugging":
+        lines.extend(
+            [
+                "## Bug Fix Patterns",
+                "",
+                "When debugging similar issues, consider these historical fixes:",
+                "",
+            ],
+        )
+        for p in patterns[:20]:  # Limit to 20 most recent
+            bug_type = p.get("bug_type", "unknown")
+            root_cause = p.get("root_cause", "Unknown")
+            fix = p.get("fix", "See commit history")
+            files = p.get("files_affected", [])
+
+            lines.append(f"### {bug_type}")
+            lines.append(f"- **Root cause**: {root_cause}")
+            lines.append(f"- **Fix**: {fix}")
+            if files:
+                lines.append(f"- **Files**: {', '.join(files[:3])}")
+            lines.append("")
+
+    elif category == "security":
+        lines.extend(
+            [
+                "## Security Decisions",
+                "",
+                "Previously reviewed security items:",
+                "",
+            ],
+        )
+        for p in patterns[:20]:
+            decision = p.get("decision", "unknown")
+            reason = p.get("reason", "")
+            lines.append(f"- **{p.get('type', 'unknown')}**: {decision}")
+            if reason:
+                lines.append(f"  - Reason: {reason}")
+            lines.append("")
+
+    elif category == "tech_debt":
+        lines.extend(
+            [
+                "## Tech Debt Tracking",
+                "",
+                "Known technical debt items:",
+                "",
+            ],
+        )
+        for p in patterns[:20]:
+            lines.append(f"- {p.get('description', str(p))}")
+
+    else:
+        lines.extend(
+            [
+                f"## {category.title()} Items",
+                "",
+            ],
+        )
+        for p in patterns[:20]:
+            lines.append(f"- {p.get('description', str(p)[:100])}")
+
+    return "\n".join(lines)

empathy_os/cli/commands/tier.py

@@ -0,0 +1,121 @@
+"""Tier management commands for intelligent model selection.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+def cmd_tier_recommend(args):
+    """Get intelligent tier recommendation for a bug/task.
+
+    Analyzes bug description and historical patterns to recommend
+    the most cost-effective tier (HAIKU/SONNET/OPUS).
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - description (str): Bug or task description to analyze.
+            - files (str | None): Comma-separated list of affected files.
+            - complexity (str | None): Complexity hint (low/medium/high).
+
+    Returns:
+        None: Prints tier recommendation with confidence and expected cost.
+    """
+    from empathy_os.tier_recommender import TierRecommender
+
+    recommender = TierRecommender()
+
+    # Get recommendation
+    result = recommender.recommend(
+        bug_description=args.description,
+        files_affected=args.files.split(",") if args.files else None,
+        complexity_hint=args.complexity,
+    )
+
+    # Display results
+    print()
+    print("=" * 60)
+    print("  TIER RECOMMENDATION")
+    print("=" * 60)
+    print()
+    print(f"  Bug/Task: {args.description}")
+    print()
+    print(f"  📍 Recommended Tier: {result.tier}")
+    print(f"  🎯 Confidence: {result.confidence * 100:.1f}%")
+    print(f"  💰 Expected Cost: ${result.expected_cost:.3f}")
+    print(f"  🔄 Expected Attempts: {result.expected_attempts:.1f}")
+    print()
+    print("  📊 Reasoning:")
+    print(f"     {result.reasoning}")
+    print()
+
+    if result.similar_patterns_count > 0:
+        print(f"  ✅ Based on {result.similar_patterns_count} similar patterns")
+    else:
+        print("  ⚠️  No historical data - using conservative default")
+
+    if result.fallback_used:
+        print()
+        print("  💡 Tip: As more patterns are collected, recommendations")
+        print("     will become more accurate and personalized.")
+
+    print()
+    print("=" * 60)
+    print()
+
+
+def cmd_tier_stats(args):
+    """Show tier pattern learning statistics.
+
+    Displays statistics about collected patterns and tier distribution.
+
+    Args:
+        args: Namespace object from argparse (no additional attributes used).
+
+    Returns:
+        None: Prints tier statistics, savings percentages, and bug type distribution.
+    """
+    from empathy_os.tier_recommender import TierRecommender
+
+    recommender = TierRecommender()
+    stats = recommender.get_stats()
+
+    print()
+    print("=" * 60)
+    print("  TIER PATTERN LEARNING STATS")
+    print("=" * 60)
+    print()
+
+    if stats.get("total_patterns", 0) == 0:
+        print("  No patterns collected yet.")
+        print()
+        print("  💡 Patterns are automatically collected as you use")
+        print("     cascading workflows with enhanced tracking enabled.")
+        print()
+        print("=" * 60)
+        print()
+        return
+
+    print(f"  Total Patterns: {stats['total_patterns']}")
+    print(f"  Avg Savings: {stats['avg_savings_percent']}%")
+    print()
+
+    print("  TIER DISTRIBUTION")
+    print("  " + "-" * 40)
+    for tier, count in stats["patterns_by_tier"].items():
+        percent = (count / stats["total_patterns"]) * 100
+        bar = "█" * int(percent / 5)
+        print(f"  {tier:10} {count:3} ({percent:5.1f}%) {bar}")
+    print()
+
+    print("  BUG TYPE DISTRIBUTION")
+    print("  " + "-" * 40)
+    sorted_types = sorted(
+        stats["bug_type_distribution"].items(), key=lambda x: x[1], reverse=True
+    )
+    for bug_type, count in sorted_types[:10]:
+        percent = (count / stats["total_patterns"]) * 100
+        print(f"  {bug_type:20} {count:3} ({percent:5.1f}%)")
+
+    print()
+    print("=" * 60)
+    print()