anvil-dev-framework 0.1.6

package/scripts/extract_patterns.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Extract patterns from recent git commits for CLAUDE.md updates.
+
+Usage: python scripts/extract_patterns.py [--days N] [--min-occurrences N]
+
+Output: JSON with extracted patterns to stdout
+"""
+
+import subprocess
+import json
+import re
+import argparse
+from collections import Counter, defaultdict
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+def get_recent_commits(days: int = 7) -> list[dict]:
+    """Get commits from the last N days."""
+    since = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
+    result = subprocess.run(
+        ['git', 'log', f'--since={since}', '--pretty=format:%s||%h||%an||%ai'],
+        capture_output=True, text=True
+    )
+
+    if result.returncode != 0:
+        return []
+
+    commits = []
+    for line in result.stdout.strip().split('\n'):
+        if not line or '||' not in line:
+            continue
+        parts = line.split('||')
+        if len(parts) >= 4:
+            commits.append({
+                'message': parts[0],
+                'hash': parts[1],
+                'author': parts[2],
+                'date': parts[3]
+            })
+    return commits
+
+
+def get_files_changed(commit_hash: str) -> list[str]:
+    """Get list of files changed in a commit."""
+    result = subprocess.run(
+        ['git', 'diff-tree', '--no-commit-id', '--name-only', '-r', commit_hash],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        return []
+    return [f for f in result.stdout.strip().split('\n') if f]
+
+
+def extract_commit_patterns(commits: list[dict], min_occurrences: int = 2) -> list[dict]:
+    """Identify patterns in commit messages."""
+    patterns = []
+
+    # Track various patterns
+    prefix_counter = Counter()
+    scope_counter = Counter()
+    issue_refs = Counter()
+    file_dir_counter = Counter()
+    fix_patterns = defaultdict(list)  # Pattern name -> list of issue refs
+
+    for commit in commits:
+        msg = commit['message']
+        commit_hash = commit['hash']
+
+        # Extract conventional commit prefix (feat, fix, docs, etc.)
+        prefix_match = re.match(r'^(\w+)(?:\(([^)]+)\))?[!:]', msg)
+        if prefix_match:
+            prefix = prefix_match.group(1).lower()
+            prefix_counter[prefix] += 1
+
+            # Extract scope if present
+            scope = prefix_match.group(2)
+            if scope:
+                scope_counter[scope.lower()] += 1
+
+        # Extract issue references (ANV-XX, ENG-XX, etc.)
+        issues = re.findall(r'([A-Z]+-\d+)', msg)
+        for issue in issues:
+            issue_refs[issue] += 1
+
+        # Track fix patterns for "Verify X Before Y" type learnings
+        if msg.startswith('fix'):
+            # Look for common fix categories
+            if 'branch' in msg.lower():
+                fix_patterns['Verify Branch Before Read'].extend(issues)
+            if 'path' in msg.lower() or 'file' in msg.lower():
+                fix_patterns['Verify File Location First'].extend(issues)
+            if 'config' in msg.lower():
+                fix_patterns['Verify Config Before Use'].extend(issues)
+
+        # Track directory patterns from changed files
+        files = get_files_changed(commit_hash)
+        for f in files:
+            parts = Path(f).parts
+            if len(parts) > 1:
+                file_dir_counter[parts[0]] += 1
+
+    # Generate patterns from collected data
+
+    # 1. Commit type patterns (if dominant type exists)
+    total_commits = len(commits)
+    for prefix, count in prefix_counter.most_common(3):
+        if count >= min_occurrences:
+            percentage = (count / total_commits) * 100
+            if percentage >= 20:  # At least 20% of commits
+                patterns.append({
+                    'name': f'{prefix.title()} Focus',
+                    'description': f'{count} {prefix} commits ({percentage:.0f}% of activity)',
+                    'evidence': ', '.join(list(issue_refs.keys())[:5]),
+                    'type': 'activity'
+                })
+
+    # 2. Scope patterns (frequently touched areas)
+    for scope, count in scope_counter.most_common(5):
+        if count >= min_occurrences:
+            patterns.append({
+                'name': f'{scope.title()} Changes',
+                'description': f'Frequent modifications to {scope} ({count} commits)',
+                'evidence': ', '.join(list(issue_refs.keys())[:3]),
+                'type': 'scope'
+            })
+
+    # 3. Fix patterns (potential learnings)
+    for pattern_name, issues in fix_patterns.items():
+        if len(issues) >= min_occurrences:
+            unique_issues = list(set(issues))[:5]
+            patterns.append({
+                'name': pattern_name,
+                'description': f'Pattern emerged from {len(issues)} related fixes',
+                'evidence': ', '.join(unique_issues),
+                'type': 'learning'
+            })
+
+    # 4. Directory focus patterns
+    for directory, count in file_dir_counter.most_common(3):
+        if count >= min_occurrences * 2 and directory not in ['.github', 'node_modules']:
+            patterns.append({
+                'name': f'{directory}/ Development',
+                'description': f'Active development in {directory}/ ({count} file changes)',
+                'evidence': ', '.join(list(issue_refs.keys())[:3]),
+                'type': 'focus'
+            })
+
+    return patterns
+
+
+def extract_retro_patterns(days: int = 7) -> list[dict]:
+    """Extract patterns from recent retrospective files."""
+    patterns = []
+    retros_dir = Path('.claude/retros')
+
+    if not retros_dir.exists():
+        return patterns
+
+    cutoff = datetime.now() - timedelta(days=days)
+
+    for retro_file in retros_dir.rglob('*.md'):
+        try:
+            # Check file modification time
+            mtime = datetime.fromtimestamp(retro_file.stat().st_mtime)
+            if mtime < cutoff:
+                continue
+
+            content = retro_file.read_text()
+
+            # Extract key learning
+            learning_match = re.search(r'## Key Learning\s*\n+(.+?)(?:\n\n|\n##|$)', content, re.DOTALL)
+            if learning_match:
+                learning = learning_match.group(1).strip()
+                # Clean up the learning text
+                learning = re.sub(r'\s+', ' ', learning)[:100]
+
+                # Extract issue references from filename or content
+                issue_match = re.search(r'([A-Z]+-\d+)', retro_file.name)
+                evidence = issue_match.group(1) if issue_match else retro_file.stem
+
+                patterns.append({
+                    'name': learning[:50] + ('...' if len(learning) > 50 else ''),
+                    'description': 'From retrospective analysis',
+                    'evidence': evidence,
+                    'type': 'retro',
+                    'source': str(retro_file)
+                })
+        except Exception:
+            continue
+
+    return patterns
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Extract patterns from git commits')
+    parser.add_argument('--days', type=int, default=7, help='Number of days to analyze')
+    parser.add_argument('--min-occurrences', type=int, default=2, help='Minimum occurrences for a pattern')
+    parser.add_argument('--include-retros', action='store_true', help='Include retrospective patterns')
+    args = parser.parse_args()
+
+    commits = get_recent_commits(args.days)
+    patterns = extract_commit_patterns(commits, args.min_occurrences)
+
+    if args.include_retros:
+        retro_patterns = extract_retro_patterns(args.days)
+        patterns.extend(retro_patterns)
+
+    output = {
+        'extracted_at': datetime.now().isoformat(),
+        'analysis_period_days': args.days,
+        'commit_count': len(commits),
+        'pattern_count': len(patterns),
+        'patterns': patterns
+    }
+
+    print(json.dumps(output, indent=2))
+
+
+if __name__ == '__main__':
+    main()