Managing Commits

{
  "feat": {
    "type": "feat",
    "description": "A new feature",
    "template": "feat({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "feat(auth): add JWT token refresh mechanism\n\nImplements automatic token refresh 5 minutes before expiration\nto maintain seamless user sessions without re-authentication.\n\nCloses #142",
        "explanation": "New authentication feature with clear description and issue reference"
      },
      {
        "message": "feat(api): add pagination support for user list endpoint\n\nAdds limit and offset query parameters.\nIncludes total count in response headers.\n\nCloses #234",
        "explanation": "API enhancement with implementation details"
      }
    ]
  },
  "fix": {
    "type": "fix",
    "description": "A bug fix",
    "template": "fix({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "fix(auth): resolve JWT validation error for expired tokens\n\nThe JWT validator was throwing unhandled errors when tokens expired.\nAdded proper error handling and user-friendly error messages.\n\nFixes #156",
        "explanation": "Bug fix explaining the problem and solution"
      },
      {
        "message": "fix(api): prevent null pointer exception in user lookup\n\nAdded null check before accessing user properties.\nReturns 404 instead of 500 when user not found.\n\nFixes #189",
        "explanation": "Bug fix with error handling improvement"
      }
    ]
  },
  "docs": {
    "type": "docs",
    "description": "Documentation only changes",
    "template": "docs({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "docs(api): update authentication endpoints documentation\n\nAdded examples for token refresh flow.\nClarified error response formats.\nUpdated JWT structure documentation.",
        "explanation": "Documentation update with specific changes listed"
      },
      {
        "message": "docs(readme): add installation instructions for Windows\n\nIncludes PowerShell and CMD examples.\nAdds troubleshooting section for common Windows issues.",
        "explanation": "README improvement for specific platform"
      }
    ]
  },
  "refactor": {
    "type": "refactor",
    "description": "Code change that neither fixes a bug nor adds a feature",
    "template": "refactor({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "refactor(auth): extract JWT utilities into separate module\n\nMoves token generation, validation, and refresh logic to\nauth/jwt-utils.ts for better organization and reusability.\n\nNo functional changes.",
        "explanation": "Refactoring that doesn't change behavior"
      },
      {
        "message": "refactor(api): simplify error handling with middleware\n\nReplaces try-catch blocks in each route with centralized\nerror handling middleware.\n\nReduces code duplication by ~200 LOC.",
        "explanation": "Refactoring that improves code quality"
      }
    ]
  },
  "test": {
    "type": "test",
    "description": "Adding or correcting tests",
    "template": "test({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "test(auth): add JWT refresh token tests\n\nAdds tests for:\n- Token refresh before expiration\n- Expired token handling\n- Invalid refresh token scenarios\n\nIncreases auth coverage to 95%.",
        "explanation": "Test addition with coverage improvement"
      },
      {
        "message": "test(api): add integration tests for user endpoints\n\nTests full request/response cycle including:\n- User creation\n- User retrieval\n- User updates\n- Error cases",
        "explanation": "Integration test suite addition"
      }
    ]
  },
  "chore": {
    "type": "chore",
    "description": "Changes to build process or auxiliary tools",
    "template": "chore({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "chore(deps): update dependencies to latest versions\n\nUpdates:\n- express: 4.17.1 -> 4.18.2\n- jsonwebtoken: 8.5.1 -> 9.0.0\n\nAll tests passing after update.",
        "explanation": "Dependency update with version details"
      },
      {
        "message": "chore(ci): add automated security scanning\n\nAdds npm audit check to CI pipeline.\nFails build if high/critical vulnerabilities found.",
        "explanation": "CI/CD improvement"
      }
    ]
  },
  "perf": {
    "type": "perf",
    "description": "A code change that improves performance",
    "template": "perf({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "perf(api): add caching for user lookup queries\n\nImplements Redis caching with 5-minute TTL.\nReduces database queries by ~80%.\nImproves response time from 150ms to 20ms.",
        "explanation": "Performance optimization with metrics"
      },
      {
        "message": "perf(auth): optimize JWT verification\n\nCaches public key for signature validation.\nReduces token verification time by 60%.",
        "explanation": "Performance improvement with measurement"
      }
    ]
  },
  "style": {
    "type": "style",
    "description": "Changes that do not affect code meaning (formatting, etc)",
    "template": "style({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "style(api): format code with Prettier\n\nApplies consistent formatting across all API files.\nNo functional changes.",
        "explanation": "Code formatting only"
      }
    ]
  },
  "ci": {
    "type": "ci",
    "description": "Changes to CI configuration files and scripts",
    "template": "ci({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "ci(github): add automated release workflow\n\nCreates GitHub releases on version tags.\nGenerates changelog from conventional commits.\nPublishes to npm automatically.",
        "explanation": "CI/CD workflow addition"
      }
    ]
  },
  "build": {
    "type": "build",
    "description": "Changes that affect the build system or dependencies",
    "template": "build({scope}): {subject}\n\n{body}\n\n{footer}",
    "examples": [
      {
        "message": "build(webpack): optimize production build\n\nEnables code splitting and tree shaking.\nReduces bundle size by 40%.",
        "explanation": "Build optimization"
      }
    ]
  },
  "revert": {
    "type": "revert",
    "description": "Reverts a previous commit",
    "template": "revert: {subject}\n\nThis reverts commit {hash}.\n\n{reason}",
    "examples": [
      {
        "message": "revert: feat(auth): add JWT token refresh\n\nThis reverts commit abc1234.\n\nReverted due to security vulnerability in refresh logic.\nWill be reimplemented with proper validation.",
        "explanation": "Revert with explanation"
      }
    ]
  }
}

#!/usr/bin/env python3
"""
Git Commit Analyzer
Analyzes commit quality, format compliance, and suggests improvements
"""

import argparse
import re
import subprocess
import sys
from typing import List, Dict, Tuple

# Color constants
RED = '\033[0;31m'
GREEN = '\033[0;32m'
YELLOW = '\033[1;33m'
BLUE = '\033[0;34m'
NC = '\033[0m'

# Conventional commit types
VALID_TYPES = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'chore', 'ci', 'build', 'revert']

# Conventional commit pattern
CONVENTIONAL_PATTERN = re.compile(
    r'^(' + '|'.join(VALID_TYPES) + r')(\([a-z0-9-]+\))?!?: .{1,50}$'
)


def run_git(args: List[str]) -> str:
    """Execute git command"""
    try:
        result = subprocess.run(['git'] + args, capture_output=True, text=True, check=True)
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        print(f"{RED}Git error: {e.stderr}{NC}", file=sys.stderr)
        return ""


def get_commits(branch: str = None, count: int = 20) -> List[Dict]:
    """Get recent commits"""
    if branch:
        # Commits on branch not in main
        range_spec = f"main...{branch}"
    else:
        range_spec = f"-{count}"

    log_output = run_git(['log', range_spec, '--format=%H|%s|%b|%an|%ae'])

    commits = []
    for line in log_output.split('\n\n'):
        if not line.strip():
            continue

        parts = line.split('|', 4)
        if len(parts) >= 2:
            commits.append({
                'hash': parts[0],
                'subject': parts[1],
                'body': parts[2] if len(parts) > 2 else '',
                'author': parts[3] if len(parts) > 3 else '',
                'email': parts[4] if len(parts) > 4 else ''
            })

    return commits


def get_commit_stats(commit_hash: str) -> Tuple[int, int]:
    """Get insertions and deletions for a commit"""
    stats = run_git(['show', '--stat', '--format=', commit_hash])

    insertions = 0
    deletions = 0

    # Parse stats line like: "5 files changed, 123 insertions(+), 45 deletions(-)"
    match = re.search(r'(\d+) insertion', stats)
    if match:
        insertions = int(match.group(1))

    match = re.search(r'(\d+) deletion', stats)
    if match:
        deletions = int(match.group(1))

    return insertions, deletions


def check_conventional_format(subject: str) -> Tuple[bool, List[str]]:
    """Check if commit message follows conventional commits"""
    issues = []

    # Check pattern
    if not CONVENTIONAL_PATTERN.match(subject):
        # Try to identify specific issues
        if not any(subject.startswith(t) for t in VALID_TYPES):
            issues.append(f"Missing or invalid type. Valid types: {', '.join(VALID_TYPES)}")

        if len(subject) > 72:
            issues.append(f"Subject too long ({len(subject)} chars). Keep under 72 chars.")

        if subject.endswith('.'):
            issues.append("Subject should not end with a period")

        if subject != subject.lower() and not any(subject.startswith(t.upper()) for t in VALID_TYPES):
            issues.append("Subject should be lowercase (except type)")

    return len(issues) == 0, issues


def analyze_commit_quality(commit: Dict) -> Dict:
    """Analyze individual commit quality"""
    subject = commit['subject']
    body = commit['body']

    quality = {
        'hash': commit['hash'][:7],
        'subject': subject,
        'score': 0,
        'issues': [],
        'suggestions': []
    }

    # Check format (weight: 30 points)
    is_conventional, format_issues = check_conventional_format(subject)
    if is_conventional:
        quality['score'] += 30
    else:
        quality['issues'].extend(format_issues)

    # Check subject quality (weight: 25 points)
    if len(subject) > 10:
        quality['score'] += 10
    else:
        quality['issues'].append("Subject too short")

    if not any(vague in subject.lower() for vague in ['wip', 'temp', 'stuff', 'things', 'update', 'fix']):
        quality['score'] += 15
    else:
        quality['issues'].append("Subject too vague")
        quality['suggestions'].append("Be more specific about what changed")

    # Check body (weight: 20 points)
    if body and len(body) > 20:
        quality['score'] += 20
    elif len(subject) > 50:
        quality['suggestions'].append("Consider adding a body to explain changes")

    # Check issue references (weight: 15 points)
    if re.search(r'(closes?|fixes?|resolves?) #\d+', body, re.IGNORECASE):
        quality['score'] += 15
    elif re.search(r'#\d+', subject + body):
        quality['score'] += 10
        quality['suggestions'].append("Use 'Closes #N' syntax for automatic issue closing")
    else:
        quality['suggestions'].append("Add issue reference if applicable")

    # Check commit size (weight: 10 points)
    insertions, deletions = get_commit_stats(commit['hash'])
    total_changes = insertions + deletions

    if total_changes < 500:
        quality['score'] += 10
    elif total_changes < 1000:
        quality['score'] += 5
        quality['suggestions'].append("Consider splitting into smaller commits")
    else:
        quality['issues'].append(f"Very large commit ({total_changes} LOC)")
        quality['suggestions'].append("Definitely split into multiple atomic commits")

    quality['size'] = total_changes

    # Overall rating
    if quality['score'] >= 80:
        quality['rating'] = f"{GREEN}Excellent{NC}"
    elif quality['score'] >= 60:
        quality['rating'] = f"{BLUE}Good{NC}"
    elif quality['score'] >= 40:
        quality['rating'] = f"{YELLOW}Needs Improvement{NC}"
    else:
        quality['rating'] = f"{RED}Poor{NC}"

    return quality


def check_format(branch: str = None):
    """Check format compliance for commits"""
    commits = get_commits(branch=branch)

    print(f"\n{'='*60}")
    print(f"Checking Conventional Commit Format")
    print(f"{'='*60}\n")

    compliant = 0
    non_compliant = 0

    for commit in commits:
        is_conventional, issues = check_conventional_format(commit['subject'])

        if is_conventional:
            print(f"{GREEN}✓{NC} {commit['hash'][:7]}: {commit['subject']}")
            compliant += 1
        else:
            print(f"{RED}✗{NC} {commit['hash'][:7]}: {commit['subject']}")
            for issue in issues:
                print(f"  - {issue}")
            non_compliant += 1

    print(f"\nCompliance: {compliant}/{len(commits)} ({compliant/len(commits)*100:.0f}%)")

    if non_compliant > 0:
        print(f"\n{YELLOW}Suggestion:{NC} Run interactive rebase to fix non-compliant messages")


def find_fixups(branch: str = None):
    """Find commits that could be squashed"""
    commits = get_commits(branch=branch)

    print(f"\n{'='*60}")
    print(f"Finding Fixup Opportunities")
    print(f"{'='*60}\n")

    fixup_candidates = []

    for i, commit in enumerate(commits):
        subject = commit['subject'].lower()

        # Check for WIP/fixup/temp commits
        if any(marker in subject for marker in ['wip', 'fixup', 'temp', 'tmp', 'checkpoint']):
            fixup_candidates.append({
                'index': i,
                'commit': commit,
                'reason': 'Temporary commit'
            })

        # Check for very similar subjects (potential duplicates)
        for j, other_commit in enumerate(commits[i+1:], start=i+1):
            if len(subject) > 10 and subject in other_commit['subject'].lower():
                fixup_candidates.append({
                    'index': i,
                    'commit': commit,
                    'related_index': j,
                    'related_commit': other_commit,
                    'reason': 'Similar to another commit'
                })
                break

    if not fixup_candidates:
        print(f"{GREEN}✓{NC} No fixup opportunities found. Commit history looks clean!")
        return

    print(f"Found {len(fixup_candidates)} fixup opportunities:\n")

    for candidate in fixup_candidates:
        commit = candidate['commit']
        print(f"{YELLOW}→{NC} {commit['hash'][:7]}: {commit['subject']}")
        print(f"  Reason: {candidate['reason']}")

        if 'related_commit' in candidate:
            related = candidate['related_commit']
            print(f"  Related: {related['hash'][:7]}: {related['subject']}")

        print()

    print(f"\n{BLUE}Suggestion:{NC} Use interactive rebase to squash/fixup these commits")


def analyze_size(branch: str = None):
    """Analyze commit sizes"""
    commits = get_commits(branch=branch)

    print(f"\n{'='*60}")
    print(f"Commit Size Analysis")
    print(f"{'='*60}\n")

    sizes = []

    for commit in commits:
        insertions, deletions = get_commit_stats(commit['hash'])
        total = insertions + deletions
        sizes.append(total)

        # Categorize
        if total < 10:
            category = f"{BLUE}Tiny{NC}"
        elif total < 50:
            category = f"{GREEN}Small{NC}"
        elif total < 200:
            category = f"{YELLOW}Medium{NC}"
        elif total < 500:
            category = f"{YELLOW}Large{NC}"
        else:
            category = f"{RED}Very Large{NC}"

        print(f"{commit['hash'][:7]}: {total:4d} LOC - {category}")
        if total > 500:
            print(f"  ⚠️  Consider splitting this commit")
        print(f"  {commit['subject']}")
        print()

    # Statistics
    avg_size = sum(sizes) / len(sizes) if sizes else 0
    print(f"\nAverage commit size: {avg_size:.0f} LOC")
    print(f"Largest commit: {max(sizes)} LOC")
    print(f"Smallest commit: {min(sizes)} LOC")


def generate_report(branch: str = None):
    """Generate comprehensive quality report"""
    commits = get_commits(branch=branch)

    print(f"\n{'='*60}")
    print(f"Commit Quality Report")
    if branch:
        print(f"Branch: {branch}")
    print(f"{'='*60}\n")

    print(f"Analyzed {len(commits)} commits\n")

    excellent = 0
    good = 0
    needs_improvement = 0
    poor = 0

    for commit in commits:
        quality = analyze_commit_quality(commit)

        print(f"{quality['hash']}: {quality['subject'][:60]}")
        print(f"  Score: {quality['score']}/100 - {quality['rating']}")

        if quality['issues']:
            print(f"  {RED}Issues:{NC}")
            for issue in quality['issues']:
                print(f"    - {issue}")

        if quality['suggestions']:
            print(f"  {BLUE}Suggestions:{NC}")
            for suggestion in quality['suggestions']:
                print(f"    - {suggestion}")

        print()

        # Count ratings
        if quality['score'] >= 80:
            excellent += 1
        elif quality['score'] >= 60:
            good += 1
        elif quality['score'] >= 40:
            needs_improvement += 1
        else:
            poor += 1

    # Summary
    print(f"\n{'='*60}")
    print("Summary")
    print(f"{'='*60}\n")
    print(f"{GREEN}Excellent:{NC} {excellent}")
    print(f"{BLUE}Good:{NC} {good}")
    print(f"{YELLOW}Needs Improvement:{NC} {needs_improvement}")
    print(f"{RED}Poor:{NC} {poor}")

    overall_quality = (excellent + good) / len(commits) * 100 if commits else 0
    print(f"\nOverall Quality: {overall_quality:.0f}%")


def main():
    parser = argparse.ArgumentParser(description='Git Commit Analyzer')
    subparsers = parser.add_subparsers(dest='command', help='Command to execute')

    # check-format
    format_parser = subparsers.add_parser('check-format', help='Check conventional commit format')
    format_parser.add_argument('--branch', help='Branch to analyze')

    # find-fixups
    fixup_parser = subparsers.add_parser('find-fixups', help='Find commits to squash/fixup')
    fixup_parser.add_argument('--branch', help='Branch to analyze')

    # analyze-size
    size_parser = subparsers.add_parser('analyze-size', help='Analyze commit sizes')
    size_parser.add_argument('--branch', help='Branch to analyze')

    # report
    report_parser = subparsers.add_parser('report', help='Generate full quality report')
    report_parser.add_argument('--branch', help='Branch to analyze')

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        return

    # Execute command
    if args.command == 'check-format':
        check_format(args.branch)
    elif args.command == 'find-fixups':
        find_fixups(args.branch)
    elif args.command == 'analyze-size':
        analyze_size(args.branch)
    elif args.command == 'report':
        generate_report(args.branch)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Conventional Commits Helper
Generates and validates conventional commit messages
"""

import argparse
import re
import subprocess
import sys

VALID_TYPES = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'chore', 'ci', 'build', 'revert']

RED = '\033[0;31m'
GREEN = '\033[0;32m'
YELLOW = '\033[1;33m'
BLUE = '\033[0;34m'
NC = '\033[0m'


def run_git(args):
    """Execute git command"""
    try:
        result = subprocess.run(['git'] + args, capture_output=True, text=True, check=True)
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        print(f"{RED}Error: {e.stderr}{NC}", file=sys.stderr)
        return ""


def validate_message(message):
    """Validate a commit message"""
    lines = message.strip().split('\n')
    subject = lines[0]

    issues = []

    # Check type
    has_valid_type = any(subject.startswith(t + ':') or subject.startswith(t + '(') for t in VALID_TYPES)
    if not has_valid_type:
        issues.append(f"Missing valid type. Use one of: {', '.join(VALID_TYPES)}")

    # Check subject length
    if len(subject) > 72:
        issues.append(f"Subject too long: {len(subject)} chars (max 72)")

    # Check subject ends with period
    if subject.endswith('.'):
        issues.append("Subject should not end with period")

    # Check imperative mood (basic heuristic)
    if any(subject.lower().startswith(t + 'ed ') for t in VALID_TYPES):
        issues.append("Use imperative mood ('add' not 'added')")

    return len(issues) == 0, issues


def generate_from_diff():
    """Generate commit message from staged changes"""
    # Get staged files
    staged = run_git(['diff', '--cached', '--name-only'])
    if not staged:
        print(f"{YELLOW}No staged changes{NC}")
        return

    files = staged.split('\n')
    print(f"\n{BLUE}Staged files:{NC}")
    for f in files[:10]:
        print(f"  - {f}")
    if len(files) > 10:
        print(f"  ... and {len(files) - 10} more")

    # Get diff stats
    stats = run_git(['diff', '--cached', '--stat'])

    # Try to infer type and scope
    scope = None
    commit_type = None

    # Infer from paths
    if any('test' in f for f in files):
        commit_type = 'test'
    elif any('.md' in f or 'doc' in f.lower() for f in files):
        commit_type = 'docs'
    elif any('ci' in f or '.github' in f for f in files):
        commit_type = 'ci'

    # Infer scope from common path prefixes
    common_paths = set()
    for f in files:
        parts = f.split('/')
        if len(parts) > 1:
            common_paths.add(parts[0])

    if len(common_paths) == 1:
        scope = list(common_paths)[0]

    print(f"\n{BLUE}Suggested:{ NC}")
    if commit_type:
        print(f"  Type: {commit_type}")
    if scope:
        print(f"  Scope: {scope}")

    print("\n" + "="*60)
    print(stats)
    print("="*60)


def interactive():
    """Interactive commit message builder"""
    print(f"\n{BLUE}=== Interactive Commit Builder ==={NC}\n")

    # Step 1: Show changes
    generate_from_diff()

    # Step 2: Get type
    print(f"\n{BLUE}Step 1: Select type{NC}")
    for i, t in enumerate(VALID_TYPES, 1):
        print(f"  {i}. {t}")

    type_choice = input("Enter number (or type name): ").strip()
    if type_choice.isdigit():
        commit_type = VALID_TYPES[int(type_choice) - 1]
    else:
        commit_type = type_choice

    # Step 3: Get scope (optional)
    print(f"\n{BLUE}Step 2: Enter scope (optional){NC}")
    scope = input("Scope: ").strip()

    # Step 4: Get subject
    print(f"\n{BLUE}Step 3: Enter subject{NC}")
    subject = input("Subject: ").strip()

    # Step 5: Get body (optional)
    print(f"\n{BLUE}Step 4: Enter body (optional, press Enter twice to finish){NC}")
    body_lines = []
    while True:
        line = input()
        if not line:
            break
        body_lines.append(line)
    body = '\n'.join(body_lines)

    # Step 6: Get footer (optional)
    print(f"\n{BLUE}Step 5: Add references (optional){NC}")
    footer = input("Footer (e.g., 'Closes #42'): ").strip()

    # Build message
    if scope:
        message_subject = f"{commit_type}({scope}): {subject}"
    else:
        message_subject = f"{commit_type}: {subject}"

    full_message = message_subject
    if body:
        full_message += "\n\n" + body
    if footer:
        full_message += "\n\n" + footer

    # Preview
    print(f"\n{'='*60}")
    print(full_message)
    print(f"{'='*60}\n")

    # Validate
    is_valid, issues = validate_message(full_message)
    if not is_valid:
        print(f"{YELLOW}Warnings:{NC}")
        for issue in issues:
            print(f"  - {issue}")
        print()

    # Confirm
    confirm = input("Commit with this message? [y/n/e(dit)]: ").strip().lower()

    if confirm == 'y':
        # Write to temp file and commit
        with open('/tmp/commit-msg.txt', 'w') as f:
            f.write(full_message)

        result = run_git(['commit', '-F', '/tmp/commit-msg.txt'])
        if result:
            print(f"\n{GREEN}✓ Committed{NC}")
    elif confirm == 'e':
        print("Opening editor...")
        subprocess.run(['git', 'commit', '-e', '-m', full_message])
    else:
        print("Cancelled")


def validate_branch(branch):
    """Validate all commits on a branch"""
    # Get commits
    commits = run_git(['log', f'main...{branch}', '--format=%H|%s']).split('\n')

    print(f"\n{'='*60}")
    print(f"Validating commits on {branch}")
    print(f"{'='*60}\n")

    valid = 0
    invalid = 0

    for commit_line in commits:
        if not commit_line:
            continue

        commit_hash, subject = commit_line.split('|', 1)
        is_valid, issues = validate_message(subject)

        if is_valid:
            print(f"{GREEN}✓{NC} {commit_hash[:7]}: {subject}")
            valid += 1
        else:
            print(f"{RED}✗{NC} {commit_hash[:7]}: {subject}")
            for issue in issues:
                print(f"  - {issue}")
            invalid += 1

    total = valid + invalid
    print(f"\nValid: {valid}/{total} ({valid/total*100:.0f}%)")


def main():
    parser = argparse.ArgumentParser(description='Conventional Commits Helper')
    subparsers = parser.add_subparsers(dest='command')

    # validate
    validate_parser = subparsers.add_parser('validate', help='Validate commit message')
    validate_parser.add_argument('message', nargs='?', help='Commit message to validate')

    # generate
    subparsers.add_parser('generate', help='Generate message from changes')

    # interactive
    subparsers.add_parser('interactive', help='Interactive commit builder')

    # validate-branch
    branch_parser = subparsers.add_parser('validate-branch', help='Validate all commits on branch')
    branch_parser.add_argument('branch', help='Branch to validate')

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        return

    if args.command == 'validate':
        if args.message:
            is_valid, issues = validate_message(args.message)
            if is_valid:
                print(f"{GREEN}✓ Valid conventional commit{NC}")
            else:
                print(f"{RED}✗ Invalid commit message{NC}")
                for issue in issues:
                    print(f"  - {issue}")
                sys.exit(1)
        else:
            print("Error: message required")
            sys.exit(1)
    elif args.command == 'generate':
        generate_from_diff()
    elif args.command == 'interactive':
        interactive()
    elif args.command == 'validate-branch':
        validate_branch(args.branch)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Intelligent File Grouping for Commits
Groups modified files by scope, type, and logical relationships
"""

import argparse
import json
import os
import re
import subprocess
import sys
from collections import defaultdict
from pathlib import Path
from typing import List, Dict, Tuple, Set

# Color constants
RED = '\033[0;31m'
GREEN = '\033[0;32m'
YELLOW = '\033[1;33m'
BLUE = '\033[0;34m'
MAGENTA = '\033[0;35m'
CYAN = '\033[0;36m'
NC = '\033[0m'

# Conventional commit types
COMMIT_TYPES = {
    'feat': 'New feature',
    'fix': 'Bug fix',
    'docs': 'Documentation',
    'test': 'Tests',
    'refactor': 'Code refactoring',
    'perf': 'Performance improvement',
    'chore': 'Maintenance',
    'ci': 'CI/CD changes',
    'build': 'Build system changes',
}

# File patterns for type detection
TYPE_PATTERNS = {
    'test': [r'\.test\.(ts|js|tsx|jsx|py)$', r'\.spec\.(ts|js|tsx|jsx)$', r'^tests?/'],
    'docs': [r'\.md$', r'^docs?/'],
    'config': [r'package\.json$', r'tsconfig\.json$', r'\.config\.(ts|js)$', r'\.(yml|yaml)$'],
}


def run_git(args: List[str]) -> str:
    """Execute git command"""
    try:
        result = subprocess.run(['git'] + args, capture_output=True, text=True, check=True)
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        print(f"{RED}Git error: {e.stderr}{NC}", file=sys.stderr)
        return ""


def get_changed_files(mode: str = 'all') -> List[Dict]:
    """Get changed files with stats"""
    files = []

    if mode == 'staged':
        # Only staged files
        status_output = run_git(['diff', '--cached', '--numstat'])
    else:
        # All changes (staged and unstaged)
        status_output = run_git(['diff', 'HEAD', '--numstat'])

    for line in status_output.split('\n'):
        if not line.strip():
            continue

        parts = line.split('\t')
        if len(parts) < 3:
            continue

        added = parts[0] if parts[0] != '-' else '0'
        removed = parts[1] if parts[1] != '-' else '0'
        filepath = parts[2]

        files.append({
            'path': filepath,
            'added': int(added),
            'removed': int(removed),
            'total_changes': int(added) + int(removed),
        })

    # Also check for untracked files if mode is 'all'
    if mode == 'all':
        untracked = run_git(['ls-files', '--others', '--exclude-standard'])
        for filepath in untracked.split('\n'):
            if filepath.strip():
                files.append({
                    'path': filepath.strip(),
                    'added': 0,  # Unknown for untracked
                    'removed': 0,
                    'total_changes': 0,
                })

    return files


def detect_scope(filepath: str) -> str:
    """Detect scope from file path"""
    path = Path(filepath)
    parts = path.parts

    # Common scope patterns
    if len(parts) >= 2:
        if parts[0] in ['src', 'lib', 'app']:
            # src/auth/jwt.ts → auth
            # src/components/Button.tsx → components or ui
            scope = parts[1]
            if scope in ['components', 'pages', 'views', 'layouts']:
                return 'ui'
            return scope
        elif parts[0] == 'tests':
            # tests/auth/jwt.test.ts → auth
            if len(parts) >= 2:
                return parts[1]

    # Fallback: use first directory
    if len(parts) > 1:
        return parts[0]

    return 'root'


def detect_type(filepath: str, added: int, removed: int) -> str:
    """Detect commit type from file characteristics"""
    # Check type patterns
    for type_name, patterns in TYPE_PATTERNS.items():
        for pattern in patterns:
            if re.search(pattern, filepath, re.IGNORECASE):
                return type_name

    # Check if it's a new file (likely feat)
    if removed == 0 and added > 0:
        return 'feat'

    # Check if it's mostly deletions (could be refactor or fix)
    if removed > added and removed > 10:
        return 'refactor'

    # Default: assume feature if substantial additions
    if added > 20:
        return 'feat'

    # Default to fix for small changes
    return 'fix'


def group_files_by_scope(files: List[Dict]) -> Dict[str, List[Dict]]:
    """Group files by scope"""
    groups = defaultdict(list)

    for file_info in files:
        scope = detect_scope(file_info['path'])
        groups[scope].append(file_info)

    return dict(groups)


def group_files_by_type_and_scope(files: List[Dict]) -> List[Dict]:
    """Intelligently group files by type and scope"""
    # First, categorize each file
    categorized = []
    for file_info in files:
        scope = detect_scope(file_info['path'])
        file_type = detect_type(file_info['path'], file_info['added'], file_info['removed'])

        categorized.append({
            **file_info,
            'scope': scope,
            'type': file_type,
        })

    # Group by (type, scope) combination
    groups = defaultdict(list)
    for file_info in categorized:
        key = (file_info['type'], file_info['scope'])
        groups[key].append(file_info)

    # Convert to list of group dicts
    result = []
    for (file_type, scope), file_list in groups.items():
        total_added = sum(f['added'] for f in file_list)
        total_removed = sum(f['removed'] for f in file_list)

        result.append({
            'type': file_type,
            'scope': scope,
            'files': file_list,
            'file_count': len(file_list),
            'lines_added': total_added,
            'lines_removed': total_removed,
            'total_changes': total_added + total_removed,
        })

    # Sort by type priority, then scope
    type_priority = {'feat': 1, 'fix': 2, 'refactor': 3, 'test': 4, 'docs': 5, 'config': 6, 'chore': 7}
    result.sort(key=lambda g: (type_priority.get(g['type'], 99), g['scope']))

    return result


def generate_commit_subject(group: Dict) -> str:
    """Generate commit subject line for a group"""
    commit_type = group['type']
    scope = group['scope']
    file_count = group['file_count']

    # Generate subject based on files
    files = group['files']
    filepaths = [f['path'] for f in files]

    # Try to infer what changed
    if commit_type == 'feat':
        if file_count == 1:
            filename = Path(filepaths[0]).stem
            subject = f"add {filename} functionality"
        else:
            subject = f"add {scope} features"
    elif commit_type == 'fix':
        subject = f"resolve {scope} errors"
    elif commit_type == 'test':
        subject = f"add {scope} tests"
    elif commit_type == 'docs':
        if 'README' in filepaths[0]:
            subject = "update README"
        else:
            subject = f"document {scope}"
    elif commit_type == 'refactor':
        subject = f"refactor {scope} implementation"
    else:
        subject = f"update {scope}"

    return subject


def format_group_display(group: Dict, index: int) -> str:
    """Format group for display"""
    icons = {
        'feat': '📦',
        'fix': '🐛',
        'test': '✅',
        'docs': '📚',
        'refactor': '♻️',
        'perf': '⚡',
        'chore': '🔧',
    }

    icon = icons.get(group['type'], '📝')
    commit_type = group['type']
    scope = group['scope']
    file_count = group['file_count']
    changes = group['total_changes']

    header = f"{icon} Group {index}: {commit_type}({scope}) - {file_count} files, {changes} LOC"

    files_display = []
    for f in group['files']:
        added = f['added']
        removed = f['removed']
        path = f['path']
        sign = '+' if added >= removed else '~'
        files_display.append(f"  {sign} {path} (+{added}, -{removed})")

    subject = generate_commit_subject(group)
    suggested_msg = f"\n  Suggested: {commit_type}({scope}): {subject}"

    return f"{CYAN}{header}{NC}\n" + "\n".join(files_display) + f"{YELLOW}{suggested_msg}{NC}"


def main():
    parser = argparse.ArgumentParser(description='Intelligently group files for commits')
    parser.add_argument('--mode', choices=['all', 'staged', 'scope'], default='all',
                       help='Grouping mode (default: all)')
    parser.add_argument('--json', action='store_true', help='Output as JSON')
    parser.add_argument('--analyze', action='store_true', help='Show analysis only')

    args = parser.parse_args()

    # Get changed files
    files = get_changed_files(args.mode)

    if not files:
        print(f"{YELLOW}No changes detected.{NC}")
        return 0

    # Group files
    if args.mode == 'scope':
        scope_groups = group_files_by_scope(files)
        print(f"\n{BLUE}Files grouped by scope:{NC}\n")
        for scope, scope_files in scope_groups.items():
            print(f"{GREEN}{scope}:{NC} {len(scope_files)} files")
            for f in scope_files:
                print(f"  - {f['path']}")
    else:
        groups = group_files_by_type_and_scope(files)

        if args.json:
            # Output as JSON
            output = {
                'total_files': len(files),
                'total_groups': len(groups),
                'groups': groups,
            }
            print(json.dumps(output, indent=2))
        else:
            # Human-readable output
            print(f"\n{BLUE}Found {len(files)} changed files in {len(groups)} logical groups:{NC}\n")
            for i, group in enumerate(groups, 1):
                print(format_group_display(group, i))
                print()

    return 0


if __name__ == '__main__':
    sys.exit(main())

#!/usr/bin/env python3
"""
Initialize GitHub workflow environment.

Usage:
    python init-environment.py              # Initialize environment
    python init-environment.py --force      # Force re-initialization
    python init-environment.py --check      # Check if initialized
    python init-environment.py --show       # Show current environment
"""

import json
import os
import re
import subprocess
import sys
from datetime import datetime, timezone, timedelta
from pathlib import Path

# Environment file location (in .claude for project-specific storage)
ENV_DIR = ".claude/github-workflows"
ENV_FILE = "env.json"

def get_env_path():
    """Get the environment file path, creating directory if needed."""
    env_dir = Path(ENV_DIR)
    env_dir.mkdir(exist_ok=True)
    return env_dir / ENV_FILE

def run_gh_command(args, default=None):
    """Run a GitHub CLI command and return output."""
    try:
        result = subprocess.run(
            ["gh"] + args,
            capture_output=True,
            text=True,
            check=True
        )
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        if default is not None:
            return default
        return None
    except FileNotFoundError:
        print("Error: GitHub CLI (gh) not found. Install from https://cli.github.com/", file=sys.stderr)
        return None

def run_git_command(args, default=None):
    """Run a git command and return output."""
    try:
        result = subprocess.run(
            ["git"] + args,
            capture_output=True,
            text=True,
            check=True
        )
        return result.stdout.strip()
    except subprocess.CalledProcessError:
        return default
    except FileNotFoundError:
        return default

def get_repository_info():
    """Get repository owner and name."""
    output = run_gh_command(["repo", "view", "--json", "owner,name,url"])
    if output:
        try:
            data = json.loads(output)
            return {
                "owner": data.get("owner", {}).get("login", "unknown"),
                "name": data.get("name", "unknown"),
                "fullName": f"{data.get('owner', {}).get('login', 'unknown')}/{data.get('name', 'unknown')}",
                "url": data.get("url", "")
            }
        except json.JSONDecodeError:
            pass
    return None

def get_user_info():
    """Get current GitHub user info."""
    output = run_gh_command(["api", "user", "--jq", ".login,.name"])
    if output:
        lines = output.split("\n")
        return {
            "login": lines[0] if len(lines) > 0 else "unknown",
            "name": lines[1] if len(lines) > 1 else ""
        }
    return None

def get_project_board(owner):
    """Get the most recent active project board."""
    # Try user projects first
    output = run_gh_command([
        "project", "list",
        "--owner", "@me",
        "--format", "json",
        "--limit", "5"
    ])

    if output:
        try:
            data = json.loads(output)
            projects = data.get("projects", [])
            if projects:
                # Return most recent (first in list)
                project = projects[0]
                return {
                    "number": project.get("number"),
                    "title": project.get("title", ""),
                    "url": project.get("url", "")
                }
        except json.JSONDecodeError:
            pass

    # Try org projects if user has none
    if owner and owner != "unknown":
        output = run_gh_command([
            "project", "list",
            "--owner", owner,
            "--format", "json",
            "--limit", "5"
        ])

        if output:
            try:
                data = json.loads(output)
                projects = data.get("projects", [])
                if projects:
                    project = projects[0]
                    return {
                        "number": project.get("number"),
                        "title": project.get("title", ""),
                        "url": project.get("url", "")
                    }
            except json.JSONDecodeError:
                pass

    return None

def get_milestone(owner, repo):
    """Get the current active milestone."""
    if not owner or not repo:
        return None

    output = run_gh_command([
        "api",
        f"repos/{owner}/{repo}/milestones",
        "--jq", ".[0] | {title: .title, number: .number, dueOn: .due_on}"
    ])

    if output:
        try:
            data = json.loads(output)
            if data.get("title"):
                return {
                    "title": data.get("title", ""),
                    "number": data.get("number"),
                    "dueOn": data.get("dueOn", "")
                }
        except json.JSONDecodeError:
            pass

    return None

def detect_branch_scope(branch_name, suggested_scopes):
    """Detect scope from branch name matching suggested scopes."""
    if not branch_name or not suggested_scopes:
        return None, None

    branch_lower = branch_name.lower()

    # Check each suggested scope
    for scope in suggested_scopes:
        scope_lower = scope.lower()
        # Match scope anywhere in branch name
        if scope_lower in branch_lower:
            return scope, f"scope:{scope}"
        # Also check hyphenated versions
        if scope_lower.replace("-", "") in branch_lower.replace("-", ""):
            return scope, f"scope:{scope}"

    # Try to extract scope from common patterns
    # e.g., feature/auth-login, fix/api-error, plugin/github-workflows
    patterns = [
        r"^(?:feature|fix|plugin|bugfix|hotfix)/([a-z0-9-]+)",
        r"^([a-z0-9-]+)/",
    ]

    for pattern in patterns:
        match = re.search(pattern, branch_lower)
        if match:
            potential_scope = match.group(1).split("-")[0]
            # Check if this matches a suggested scope
            for scope in suggested_scopes:
                if potential_scope == scope.lower():
                    return scope, f"scope:{scope}"

    return None, None


def get_branch_info(suggested_scopes=None):
    """Get current branch and detect related issues and scope."""
    branch_name = run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])

    if not branch_name:
        return None

    # Extract issue numbers from branch name (can have multiple)
    issue_numbers = []
    patterns = [
        r"issue-(\d+)",
        r"/(\d+)-",
        r"^(\d+)-",
        r"-(\d+)(?:$|-)"
    ]

    for pattern in patterns:
        matches = re.findall(pattern, branch_name)
        for match in matches:
            num = int(match)
            if num not in issue_numbers:
                issue_numbers.append(num)

    # Detect scope from branch name
    detected_scope = None
    scope_label = None
    if suggested_scopes:
        detected_scope, scope_label = detect_branch_scope(branch_name, suggested_scopes)

    return {
        "name": branch_name,
        "relatedIssues": issue_numbers if issue_numbers else [],
        "detectedScope": detected_scope,
        "scopeLabel": scope_label
    }

def get_suggested_scopes():
    """Get suggested scopes from git-conventional-commits.json or project structure."""
    scopes = []

    # First check for configured scopes in git-conventional-commits.json
    config_path = Path("git-conventional-commits.json")
    if config_path.exists():
        try:
            with open(config_path) as f:
                data = json.load(f)
                configured_scopes = data.get("convention", {}).get("commitScopes", [])
                if configured_scopes:
                    return configured_scopes
        except Exception:
            pass

    # Check for plugin directories
    try:
        plugin_dirs = []
        for item in Path(".").iterdir():
            if item.is_dir() and (item / "plugin.json").exists():
                plugin_dirs.append(item.name)
            elif item.is_dir() and (item / ".claude-plugin" / "plugin.json").exists():
                plugin_dirs.append(item.name)

        if plugin_dirs:
            return plugin_dirs
    except Exception:
        pass

    # Fall back to top-level directories (excluding common non-scopes)
    exclude = {"node_modules", "dist", "build", "coverage", ".git", ".claude", "__pycache__", ".venv", "venv"}
    try:
        scopes = [
            d.name for d in Path(".").iterdir()
            if d.is_dir() and d.name not in exclude and not d.name.startswith(".")
        ]
    except Exception:
        pass

    return scopes


def get_label_stocktake():
    """Get existing labels and identify missing standard labels."""
    # Standard labels we expect
    standard_labels = {
        # Type labels
        "bug", "feature", "enhancement", "documentation", "refactor", "chore",
        # Priority labels
        "priority:critical", "priority:high", "priority:medium", "priority:low"
    }

    # Get existing labels
    output = run_gh_command([
        "label", "list",
        "--json", "name",
        "--limit", "100"
    ])

    existing_labels = set()
    if output:
        try:
            data = json.loads(output)
            existing_labels = {label.get("name", "") for label in data}
        except json.JSONDecodeError:
            pass

    # Find missing labels
    missing = sorted(list(standard_labels - existing_labels))

    # Recommended labels (the type labels)
    recommended = ["bug", "feature", "enhancement", "documentation", "refactor", "chore"]

    return {
        "existing": len(existing_labels),
        "missing": missing,
        "recommended": recommended
    }


def get_issue_cache_info():
    """Get information about the issue cache."""
    cache_path = Path(".claude/github-workflows") / "active-issues.json"

    if not cache_path.exists():
        return None

    try:
        with open(cache_path) as f:
            data = json.load(f)
            return {
                "count": len(data.get("issues", [])),
                "lastSync": data.get("lastSync", ""),
                "filter": data.get("filter", "")
            }
    except Exception:
        return None

def sync_issues():
    """Sync issues using the issue-tracker script."""
    script_dir = Path(__file__).parent
    tracker_script = script_dir / "issue-tracker.py"

    if tracker_script.exists():
        try:
            subprocess.run(
                [sys.executable, str(tracker_script), "sync", "assigned"],
                capture_output=True,
                check=True
            )
            return True
        except subprocess.CalledProcessError:
            pass

    return False

def load_environment():
    """Load existing environment file."""
    env_path = get_env_path()
    if env_path.exists():
        try:
            with open(env_path) as f:
                return json.load(f)
        except Exception:
            pass
    return None

def is_initialized_today():
    """Check if environment was initialized today."""
    env = load_environment()
    if not env:
        return False

    try:
        init_time = datetime.fromisoformat(env["initialized"].replace("Z", "+00:00"))
        now = datetime.now(timezone.utc)
        return (now - init_time) < timedelta(hours=24)
    except Exception:
        return False

def initialize_environment(force=False):
    """Initialize the GitHub workflow environment."""

    # Check if already initialized
    if not force and is_initialized_today():
        print("Environment already initialized today. Use --force to re-initialize.")
        show_environment()
        return True

    print("Initializing GitHub workflow environment...\n")

    # Gather all context
    env = {
        "initialized": datetime.now(timezone.utc).isoformat()
    }

    # Repository info
    print("  Detecting repository...", end=" ")
    repo_info = get_repository_info()
    if repo_info:
        env["repository"] = repo_info
        print(f"✓ {repo_info['fullName']}")
    else:
        print("✗ Not found")
        return False

    # User info
    print("  Getting user info...", end=" ")
    user_info = get_user_info()
    if user_info:
        env["user"] = user_info
        print(f"✓ {user_info['login']}")
    else:
        print("✗ Not authenticated")

    # Project board
    print("  Finding project board...", end=" ")
    owner = repo_info.get("owner", "") if repo_info else ""
    project = get_project_board(owner)
    if project:
        env["projectBoard"] = project
        print(f"✓ {project['title']} (#{project['number']})")
    else:
        print("- None found")

    # Milestone
    print("  Getting milestone...", end=" ")
    repo_name = repo_info.get("name", "") if repo_info else ""
    milestone = get_milestone(owner, repo_name)
    if milestone:
        env["milestone"] = milestone
        due = f" (due {milestone['dueOn'][:10]})" if milestone.get('dueOn') else ""
        print(f"✓ {milestone['title']}{due}")
    else:
        print("- None active")

    # Get suggested scopes for branch detection
    print("  Analyzing project scopes...", end=" ")
    suggested_scopes = get_suggested_scopes()
    if suggested_scopes:
        print(f"✓ {len(suggested_scopes)} scopes")
    else:
        print("- None detected")

    # Get label stocktake
    print("  Checking labels...", end=" ")
    label_stocktake = get_label_stocktake()
    env["labels"] = {
        "existing": label_stocktake["existing"],
        "missing": label_stocktake["missing"],
        "recommended": label_stocktake["recommended"],
        "suggestedScopes": suggested_scopes if suggested_scopes else []
    }
    if label_stocktake["missing"]:
        print(f"✓ {label_stocktake['existing']} labels ({len(label_stocktake['missing'])} missing)")
    else:
        print(f"✓ {label_stocktake['existing']} labels (all standard present)")

    # Branch info
    print("  Detecting branch...", end=" ")
    branch = get_branch_info(suggested_scopes)
    if branch:
        env["branch"] = branch
        issues_str = ""
        if branch.get('relatedIssues'):
            issue_nums = ", #".join(str(n) for n in branch['relatedIssues'])
            issues_str = f" → Issues #{issue_nums}"
        scope_str = ""
        if branch.get('detectedScope'):
            scope_str = f" [{branch['detectedScope']}]"
        print(f"✓ {branch['name']}{issues_str}{scope_str}")
    else:
        print("- Not in git repo")

    # Sync issues
    print("  Syncing issues...", end=" ")
    if sync_issues():
        cache_info = get_issue_cache_info()
        if cache_info:
            env["issueCache"] = cache_info
            print(f"✓ {cache_info['count']} issues cached")
        else:
            print("✓ Done")
    else:
        print("- Sync failed")

    # Add preferences section
    env["preferences"] = {
        "projectType": "personal",  # Default to personal project
        "defaultIssueFilter": "all",  # Default to all issues for personal projects
        "defaultProject": project.get("number") if project else None
    }

    # Add setup section
    env["setup"] = {
        "labelsComplete": len(label_stocktake["missing"]) == 0,
        "projectBoardExists": project is not None,
        "milestonesExist": milestone is not None
    }

    # Save environment
    env_path = get_env_path()
    with open(env_path, "w") as f:
        json.dump(env, f, indent=2)

    print(f"\n✅ Environment saved to {env_path}")

    # Show summary
    print("\n" + "=" * 50)
    show_summary(env)

    return True

def show_environment():
    """Show current environment details."""
    env = load_environment()
    if not env:
        print("Environment not initialized. Run: python init-environment.py")
        return

    print(json.dumps(env, indent=2))

def show_summary(env):
    """Show a summary of the environment."""
    print("\n📋 Workflow Environment Summary\n")

    if env.get("repository"):
        print(f"Repository: {env['repository']['fullName']}")

    if env.get("user"):
        print(f"User: {env['user']['login']}")

    if env.get("projectBoard"):
        print(f"Project Board: {env['projectBoard']['title']} (#{env['projectBoard']['number']})")

    if env.get("milestone"):
        due = f" - due {env['milestone']['dueOn'][:10]}" if env['milestone'].get('dueOn') else ""
        print(f"Milestone: {env['milestone']['title']}{due}")

    if env.get("branch"):
        issues = ""
        if env['branch'].get('relatedIssues'):
            issue_nums = ", #".join(str(n) for n in env['branch']['relatedIssues'])
            issues = f" → Issues #{issue_nums}"
        print(f"Branch: {env['branch']['name']}{issues}")
        if env['branch'].get('detectedScope'):
            print(f"  Scope: {env['branch']['detectedScope']} ({env['branch'].get('scopeLabel', '')})")

    if env.get("labels", {}).get("suggestedScopes"):
        print(f"Suggested Scopes: {', '.join(env['labels']['suggestedScopes'][:5])}")

    if env.get("issueCache"):
        print(f"Cached Issues: {env['issueCache']['count']}")

    # Display label stocktake
    if env.get("labels"):
        labels = env["labels"]
        print(f"\n📋 Label Stocktake:")
        print(f"  Existing: {labels.get('existing', 0)} labels")
        if labels.get("missing"):
            print(f"  Missing: {len(labels['missing'])} standard labels")
            for label in labels["missing"][:5]:
                print(f"    - {label}")
            if len(labels["missing"]) > 5:
                print(f"    ... and {len(labels['missing']) - 5} more")

    # Display preferences
    if env.get("preferences"):
        prefs = env["preferences"]
        print(f"\n⚙️  Preferences:")
        print(f"  Project Type: {prefs.get('projectType', 'personal')}")
        print(f"  Default Issue Filter: {prefs.get('defaultIssueFilter', 'all')}")
        if prefs.get("defaultProject"):
            print(f"  Default Project: #{prefs['defaultProject']}")

    # Display setup recommendations
    if env.get("setup"):
        setup = env["setup"]
        print(f"\n🔧 Setup Recommendations:")
        if setup.get("labelsComplete"):
            print("  ✅ All standard labels present")
        else:
            print("  ⚠️  Missing labels - run /github-workflows:label-sync standard to create")
        if setup.get("projectBoardExists"):
            print("  ✅ Project board exists")
        else:
            print("  ⚠️  No project board - run /github-workflows:project-create to create")
        if setup.get("milestonesExist"):
            print("  ✅ Active milestone found")
        else:
            print("  ⚠️  No active milestone - run /github-workflows:milestone-create to create")

    print("\n💡 Tips:")
    print("  - Use /commit-smart to commit with auto issue refs")
    print("  - Use /workflow-status for detailed workflow state")
    print("  - Use /issue-track to refresh issue cache")

def check_initialized():
    """Check if environment is initialized and recent."""
    if is_initialized_today():
        print("initialized")
        return 0
    elif load_environment():
        print("stale")
        return 1
    else:
        print("not_initialized")
        return 2

def main():
    if len(sys.argv) < 2:
        initialize_environment()
        return

    arg = sys.argv[1]

    if arg == "--force":
        initialize_environment(force=True)
    elif arg == "--check":
        sys.exit(check_initialized())
    elif arg == "--show":
        show_environment()
    elif arg == "--summary":
        env = load_environment()
        if env:
            show_summary(env)
        else:
            print("Not initialized")
    else:
        print(f"Unknown argument: {arg}")
        print(__doc__)

if __name__ == "__main__":
    main()