attune-ai 2.0.0__py3-none-any.whl

attune/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 attune.config import _validate_file_path
+from attune.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)

attune/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 attune.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 attune.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()

attune/cli/commands/utilities.py

@@ -0,0 +1,114 @@
+"""Utility commands for Empathy Framework CLI.
+
+General-purpose utility commands (sync, cheatsheet, dashboard, etc.).
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import subprocess
+import sys
+
+import typer
+from rich.panel import Panel
+
+from attune.cli.core import console
+
+# Create the utilities Typer app
+utilities_app = typer.Typer(
+    help="Utility tools - project init, cheatsheet, dashboard, costs",
+    no_args_is_help=True,
+)
+
+
+@utilities_app.command("sync-claude")
+def sync_claude(
+    source: str = typer.Option("patterns", "--source", "-s", help="Source to sync"),
+) -> None:
+    """Sync patterns to Claude Code memory."""
+    subprocess.run(["empathy-sync-claude", "--source", source], check=False)
+
+
+@utilities_app.command("cheatsheet")
+def cheatsheet() -> None:
+    """Show quick reference for all commands."""
+    console.print(
+        Panel.fit(
+            """[bold]Getting Started[/bold]
+  empathy morning           Start-of-day briefing
+  empathy health            Quick health check
+  empathy ship              Pre-commit validation
+  empathy run               Interactive REPL
+
+[bold]Memory System[/bold]
+  empathy memory status     Check Redis & patterns
+  empathy memory start      Start Redis server
+  empathy memory patterns   List stored patterns
+
+[bold]Cross-Session Service[/bold]
+  empathy service start     Start coordination service
+  empathy service status    Show service & sessions
+  empathy service sessions  List active agents
+
+[bold]Provider Config[/bold]
+  empathy provider          Show current config
+  empathy provider --set hybrid    Use best-of-breed
+  empathy provider registry        List all models
+
+[bold]Code Inspection[/bold]
+  empathy scan .            Scan for issues
+  empathy inspect .         Deep analysis (SARIF)
+  empathy fix-all           Auto-fix everything
+
+[bold]Profiling[/bold]
+  empathy profile memory-scan   Scan for memory leaks
+  empathy profile hot-files     Show riskiest files
+  empathy profile memory-test   Profile memory module
+
+[bold]Pattern Learning[/bold]
+  empathy learn --analyze 20    Learn from commits
+  empathy utilities sync-claude Sync to Claude Code
+
+[bold]Workflows[/bold]
+  empathy workflow list     Show available workflows
+  empathy workflow run <name>   Execute a workflow
+  empathy workflow create <name> -p <patterns>  Create workflow (12x faster)
+  empathy workflow list-patterns                List available patterns
+
+[bold]Workflows[/bold]
+  empathy workflow list       Show available workflows
+  empathy workflow run <name> Execute a workflow
+  empathy workflow create <name> -d <domain>  Create workflow (12x faster)
+  empathy workflow list-patterns              List available patterns
+
+[bold]Usage Telemetry[/bold]
+  empathy telemetry show    View recent LLM calls & costs
+  empathy telemetry savings Calculate cost savings (tier routing)
+  empathy telemetry export  Export usage data (JSON/CSV)""",
+            title="[bold blue]Empathy Framework Cheatsheet[/bold blue]",
+        )
+    )
+
+
+@utilities_app.command("dashboard")
+def dashboard() -> None:
+    """Launch visual dashboard."""
+    subprocess.run([sys.executable, "-m", "attune.cli", "dashboard"], check=False)
+
+
+@utilities_app.command("costs")
+def costs() -> None:
+    """View API cost tracking."""
+    subprocess.run([sys.executable, "-m", "attune.cli", "costs"], check=False)
+
+
+@utilities_app.command("init")
+def init() -> None:
+    """Create a new configuration file."""
+    subprocess.run([sys.executable, "-m", "attune.cli", "init"], check=False)
+
+
+@utilities_app.command("status")
+def status() -> None:
+    """What needs attention now."""
+    subprocess.run([sys.executable, "-m", "attune.cli", "status"], check=False)