/skills-audit                    # Run full analysis, generate reports, no changes
/skills-consolidate             # Execute consolidation after user review and approval
/skills-merge <skill1> <skill2>  # Interactive merge assistance for two skills
/skills-archive <skill-name>    # Safely archive a skill with backup
/skills-config                  # View or update configuration settings

# Find all dependency files
find . -name "package.json" -o -name "requirements.txt" -o -name "pom.xml" \
  -o -name "go.mod" -o -name "Cargo.toml" -o -name "composer.json" \
  -o -name "Gemfile" -o -name "build.gradle"

# Extract technologies
if [ -f "package.json" ]; then
  echo "Node.js project detected"
  cat package.json | jq -r '.dependencies, .devDependencies | keys[]' | head -20
fi

if [ -f "requirements.txt" ]; then
  echo "Python project detected"
  grep -v "^#" requirements.txt | cut -d'=' -f1 | head -20
fi

# Analyze directory structure
echo "=== Project Structure Analysis ==="
for dir in src lib app components services docs k8s docker; do
  if [ -d "$dir" ]; then
    file_count=$(find "$dir" -type f | wc -l)
    echo "$dir/ - $file_count files"
  fi
done

# Identify key file types
echo "=== File Type Distribution ==="
find . -type f -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" | \
  cut -d'.' -f3 | sort | uniq -c | sort -nr

{
  "system_reality": {
    "project_type": "Vue.js TypeScript Application",
    "primary_technologies": ["Vue 3", "TypeScript", "Vite", "Pinia"],
    "databases": ["IndexedDB", "LocalStorage"],
    "frameworks": ["Vue.js", "Tailwind CSS"],
    "build_tools": ["Vite", "ESLint", "TypeScript"],
    "directory_structure": {
      "src/": "234 files",
      "components/": "45 files",
      "docs/": "12 files"
    }
  },
  "relevance_domains": ["frontend", "vue.js", "typescript", "pinia", "productivity"]
}

# Scan skills directory
echo "=== Skills Inventory ==="
for skill in .claude/skills/*.md; do
  if [ -f "$skill" ]; then
    skill_name=$(basename "$skill" .md)
    skill_size=$(wc -l < "$skill")
    last_modified=$(git log -1 --format="%ci" "$skill" 2>/dev/null || echo "unknown")
    echo "✅ $skill_name - $skill_size lines - last: $last_modified"
  fi
done

def extract_skill_metadata(skill_file):
    """Extract key metadata from skill markdown file"""
    with open(skill_file, 'r', encoding='utf-8') as f:
        content = f.read()

    # Extract YAML frontmatter
    frontmatter_match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
    if frontmatter_match:
        try:
            import yaml
            metadata = yaml.safe_load(frontmatter_match.group(1))
        except:
            metadata = {}
    else:
        metadata = {}

    # Extract capabilities from content
    capabilities = []
    if 'Capabilities:' in content:
        cap_section = re.search(r'Capabilities:(.*?)(?:\n##|\Z)', content, re.DOTALL)
        if cap_section:
            capabilities = re.findall(r'[-*]\s*(.+)', cap_section.group(1))

    # Extract activation triggers
    triggers = []
    if 'triggers' in metadata:
        if isinstance(metadata['triggers'], list):
            triggers = metadata['triggers']
        elif isinstance(metadata['triggers'], str):
            triggers = [metadata['triggers']]

    return {
        'name': metadata.get('name', skill_file.stem),
        'description': metadata.get('description', ''),
        'category': metadata.get('category', 'general'),
        'triggers': triggers,
        'capabilities': capabilities,
        'file_size': len(content),
        'last_modified': get_git_last_modified(skill_file)
    }

# Search git history for skill mentions
echo "=== Skill Usage Analysis (Last 90 Days) ==="
since_date=$(date -d "90 days ago" --iso-8601)

for skill in .claude/skills/*.md; do
  skill_name=$(basename "$skill" .md)

  # Count commits mentioning this skill
  commit_count=$(git log --since="$since_date" --grep="$skill_name" --oneline | wc -l)

  # Count file mentions in commit messages
  message_count=$(git log --since="$since_date" --all --grep="$skill_name" --oneline | wc -l)

  total_usage=$((commit_count + message_count))

  if [ $total_usage -gt 0 ]; then
    echo "📊 $skill_name - $total_usage uses in last 90 days"
  else
    echo "⚠️  $skill_name - No recent usage detected"
  fi
done

def analyze_skill_dependencies(skills_dir):
    """Analyze how skills reference each other"""
    dependencies = {}

    for skill_file in Path(skills_dir).glob("*.md"):
        skill_name = skill_file.stem
        with open(skill_file, 'r', encoding='utf-8') as f:
            content = f.read()

        # Find references to other skills
        skill_references = re.findall(r'\b([a-z][a-z0-9-]*)\b', content.lower())

        # Filter to actual skill names
        other_skills = [f.stem for f in Path(skills_dir).glob("*.md") if f.stem != skill_name]
        referenced_skills = [ref for ref in skill_references if ref in other_skills]

        if referenced_skills:
            dependencies[skill_name] = referenced_skills

    return dependencies

{
  "skills_inventory": {
    "total_skills": 47,
    "categories": {
      "debug": 12,
      "create": 8,
      "fix": 15,
      "optimize": 5,
      "meta": 7
    },
    "usage_stats": {
      "vue-debugging": {"uses_90_days": 23, "last_used": "2025-11-20"},
      "pinia-fixer": {"uses_90_days": 15, "last_used": "2025-11-18"},
      "old-deprecated-skill": {"uses_90_days": 0, "last_used": "2024-06-01"}
    },
    "dependencies": {
      "vue-debugging": ["dev-vue"],
      "comprehensive-system-analyzer": ["qa-testing", "dev-debugging"]
    }
  }
}

def calculate_necessity_score(skill_data, project_reality, usage_stats):
    """Calculate necessity score for a skill (0-100)"""

    score = 0

    # Base score from recent usage (40 points max)
    usage = usage_stats.get(skill_data['name'], {})
    recent_uses = usage.get('uses_90_days', 0)
    usage_score = min(recent_uses * 2, 40)  # 2 points per use, max 40
    score += usage_score

    # Project relevance score (30 points max)
    skill_domains = extract_domains(skill_data['description'], skill_data['capabilities'])
    project_domains = project_reality.get('relevance_domains', [])

    domain_overlap = len(set(skill_domains) & set(project_domains))
    relevance_score = min(domain_overlap * 10, 30)  # 10 points per matching domain
    score += relevance_score

    # Category importance score (20 points max)
    important_categories = ['debug', 'create', 'fix']
    if skill_data['category'] in important_categories:
        score += 20
    elif skill_data['category'] in ['optimize', 'analyze']:
        score += 15
    else:
        score += 10

    # Dependency score (10 points max)
    if skill_data['name'] in usage_stats.get('dependencies', {}):
        dependent_count = len(usage_stats['dependencies'][skill_data['name']])
        dependency_score = min(dependent_count * 2, 10)
        score += dependency_score

    return min(score, 100)

def analyze_capability_overlap(skill1_data, skill2_data):
    """Calculate overlap between two skills based on capabilities and triggers"""

    # Extract keywords from descriptions and capabilities
    def extract_keywords(text):
        words = re.findall(r'\b[a-z]{3,}\b', text.lower())
        stop_words = {'the', 'and', 'for', 'with', 'can', 'will', 'use', 'from', 'have', 'this', 'that'}
        return [w for w in words if w not in stop_words]

    # Combine text sources
    skill1_text = f"{skill1_data['description']} {' '.join(skill1_data['capabilities'])} {' '.join(skill1_data['triggers'])}"
    skill2_text = f"{skill2_data['description']} {' '.join(skill2_data['capabilities'])} {' '.join(skill2_data['triggers'])}"

    # Extract keywords
    skill1_keywords = set(extract_keywords(skill1_text))
    skill2_keywords = set(extract_keywords(skill2_text))

    # Calculate Jaccard similarity
    if not skill1_keywords and not skill2_keywords:
        return 0.0

    intersection = len(skill1_keywords & skill2_keywords)
    union = len(skill1_keywords | skill2_keywords)

    return intersection / union if union > 0 else 0.0

def analyze_trigger_conflicts(all_skills):
    """Find skills with overlapping activation triggers"""

    trigger_map = defaultdict(list)

    for skill_name, skill_data in all_skills.items():
        for trigger in skill_data['triggers']:
            # Normalize trigger text
            normalized_trigger = trigger.lower().strip()
            trigger_map[normalized_trigger].append(skill_name)

    conflicts = []
    for trigger, skills in trigger_map.items():
        if len(skills) > 1:
            conflicts.append({
                'trigger': trigger,
                'conflicting_skills': skills,
                'conflict_type': 'exact_match'
            })

    return conflicts

{
  "necessity_scores": {
    "vue-debugging": 85,
    "pinia-fixer": 72,
    "comprehensive-system-analyzer": 68,
    "old-unused-skill": 15
  },
  "redundancy_analysis": {
    "overlapping_skills": [
      {
        "skill1": "component-debugger",
        "skill2": "vue-component-debugger",
        "similarity": 0.87,
        "shared_capabilities": ["debug Vue components", "fix reactivity issues"],
        "recommendation": "Consider merging"
      }
    ],
    "trigger_conflicts": [
      {
        "trigger": "fix vue component",
        "conflicting_skills": ["vue-debugger", "component-debugger", "reactivity-fixer"],
        "recommendation": "Refine trigger specificity"
      }
    ]
  },
  "consolidation_candidates": {
    "merge_candidates": [
      {
        "primary_skill": "vue-debugging",
        "merge_with": ["component-debugger", "reactivity-fixer"],
        "confidence": 0.92,
        "risk": "low"
      }
    ],
    "archive_candidates": [
      {
        "skill": "old-deprecated-skill",
        "reason": "No usage in 180+ days, obsolete capabilities",
        "confidence": 0.98,
        "risk": "low"
      }
    ]
  }
}

# Skills Consolidation Plan
**Generated:** 2025-11-23 15:30 IST
**Conservatism Level:** balanced
**Total Skills Analyzed:** 47

---

## Executive Summary

- **High Priority Actions:** 5 skills (3 merges, 2 archives)
- **Medium Priority Actions:** 8 skills (4 merges, 4 archives)
- **Low Priority Actions:** 3 skills (review needed)
- **Protected Skills:** 12 (will not be modified)

**Estimated Impact:** Reduce skills from 47 to 32 (32% reduction)

---

## High Priority Actions

### 1. Merge Vue Debugging Skills
**Action:** Merge `component-debugger` + `reactivity-fixer` → `vue-debugging`

**Rationale:**
- 92% capability overlap
- `vue-debugging` has 3x more usage
- All triggers can be consolidated
- Low risk (complementary, not conflicting)

**Risk Assessment:** LOW
- Backup will be created
- All functionality preserved
- Rollback available via git revert

**User Confirmation Required:** ⚠️ YES

### 2. Archive Obsolete Skills
**Action:** Archive `old-webpack-configurator`

**Rationale:**
- No usage in 210+ days
- References obsolete webpack v3
- Modern skills cover same functionality better

**Risk Assessment:** LOW
- Moved to `skills-archive/` directory
- Preserved in git history
- Can be restored if needed

**User Confirmation Required:** ⚠️ YES

---

## Protected Skills (Will NOT be modified)

- `skill-creator-doctor` - Meta skill, critical for system
- `dev-debugging` - Core debugging functionality
- `basic-coding` - Fundamental capability
- `git-workflow-helper` - Essential for development workflow

---

## Execution Plan

1. **Pre-execution Backup**: Create `.claude/skills-backup-YYYYMMDD/`
2. **Create Branch**: `skills/consolidation-YYYYMMDD`
3. **Batch 1**: Archive obsolete skills (low risk)
4. **Batch 2**: Merge overlapping skills (medium risk)
5. **Batch 3**: Update references and triggers
6. **Validation**: Test all skill activations
7. **Cleanup**: Remove placeholder files

**Rollback Instructions:**
```bash
# Complete rollback
git checkout main
git branch -D skills/consolidation-YYYYMMDD
cp -r .claude/skills-backup-YYYYMMDD/* .claude/skills/

# Partial rollback (batch-specific)
git revert <commit-hash>

### 3.3 User Confirmation Process

**Interactive Confirmation Flow:**

```python
def get_user_confirmation(action_details):
    """Get explicit user confirmation for each action"""

    print(f"\n=== Action Review ===")
    print(f"Type: {action_details['type']}")
    print(f"Skills: {action_details['skills']}")
    print(f"Risk Level: {action_details['risk'].upper()}")
    print(f"Rationale: {action_details['rationale']}")

    if action_details['risk'] == 'high':
        print(f"\n⚠️  HIGH RISK ACTION")
        print(f"This action {action_details['warning']}")

        response = input(f"\nProceed with {action_details['type']}? (Type 'YES' to confirm): ")
        return response == 'YES'

    else:
        print(f"\nRisk: {action_details['risk']}")
        response = input(f"Proceed with {action_details['type']}? (y/n): ")
        return response.lower() in ['y', 'yes']

echo "=== Pre-Execution Safety Checklist ==="

# Check git status
if [ -n "$(git status --porcelain)" ]; then
  echo "❌ Working directory not clean. Please commit or stash changes."
  exit 1
fi

# Create backup
BACKUP_DIR=".claude/skills-backup-$(date +%Y%m%d-%H%M%S)"
if [ ! -d "$BACKUP_DIR" ]; then
  echo "📦 Creating backup..."
  cp -r .claude/skills "$BACKUP_DIR/"
  echo "✅ Backup created: $BACKUP_DIR"
fi

# Create working branch
BRANCH="skills/consolidation-$(date +%Y%m%d-%H%M%S)"
git checkout -b "$BRANCH"
echo "✅ Working on branch: $BRANCH"

# Validate skills can still load
echo "🔍 Validating current skill integrity..."
# Add skill loading validation here

echo "=== Batch 1: Archiving Obsolete Skills ==="

for skill in "${ARCHIVE_CANDIDATES[@]}"; do
  echo "Archiving: $skill"

  # Create archive directory if needed
  mkdir -p .claude/skills-archive

  # Move skill with git history
  git mv ".claude/skills/$skill.md" ".claude/skills-archive/$skill.md"

  # Create ARCHIVED.md note
  cat > ".claude/skills-archive/$skill.md" << EOF
# Archived: $skill

**Archive Date:** $(date -Iseconds)
**Reason:** ${ARCHIVE_REASONS[$skill]}

## Archive Reason
${ARCHIVE_DETAILS[$skill]}

## Restoration Instructions
To restore this skill:
1. Move from skills-archive/ back to skills/
2. Update .claude/config/skills.json if needed
3. Test skill loading
EOF

  echo "✅ Archived: $skill"
done

git commit -m "skills: archive obsolete skills

- Archived ${#ARCHIVE_CANDIDATES[@]} obsolete skills
- Moved to skills-archive/ directory
- Preserved git history and metadata

Skills archived:
$(printf '  - %s\n' "${ARCHIVE_CANDIDATES[@]}")
"

echo "=== Batch 2: Merging Overlapping Skills ==="

for merge_group in "${MERGE_CANDIDATES[@]}"; do
  IFS='|' read -r primary_skill merge_skills <<< "$merge_group"

  echo "Merging into: $primary_skill"
  echo "From: $merge_skills"

  # Get user confirmation for this merge
  echo "About to merge skills into $primary_skill"
  echo "This will combine capabilities and update triggers"

  read -p "Proceed with merge? (y/n): " -n 1 -r
  echo
  if [[ $REPLY =~ ^[Yy]$ ]]; then
    # Perform merge operation
    python3 .claude/skills/skills-manager/scripts/merge_skills.py \
      --primary "$primary_skill" \
      --secondary $merge_skills

    # Remove merged skills
    for skill in $merge_skills; do
      git mv ".claude/skills/$skill.md" ".claude/skills-archive/merged-$skill.md"
    done

    echo "✅ Merge completed: $primary_skill"
  else
    echo "⏭️  Skipping merge: $primary_skill"
  fi
done

git commit -m "skills: merge overlapping skills

Consolidated skills with high capability overlap:
- Combined complementary capabilities
- Updated triggers to prevent conflicts
- Preserved all unique functionality
- Archived merged originals for reference"

echo "=== Post-Execution Validation ==="

# Validate all skills can load
echo "🔍 Testing skill loading..."
load_errors=0
for skill in .claude/skills/*.md; do
  if [ -f "$skill" ]; then
    # Test skill syntax/loading
    if ! python3 -c "
import yaml
import re
with open('$skill', 'r') as f:
    content = f.read()
# Basic validation
frontmatter_match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
if not frontmatter_match:
    exit(1)
" 2>/dev/null; then
      echo "❌ Skill validation failed: $(basename "$skill")"
      load_errors=$((load_errors + 1))
    fi
  fi
done

if [ $load_errors -eq 0 ]; then
  echo "✅ All skills validated successfully"
else
  echo "❌ $load_errors skills have validation errors"
  echo "Please review and fix before continuing"
fi

# Test registry consistency
echo "🔍 Validating registry consistency..."
python3 .claude/skills/skills-manager/scripts/validate_registry.py

echo "=== Consolidation Complete ==="
echo "Branch: $BRANCH"
echo "Backup: $BACKUP_DIR"
echo ""
echo "Next steps:"
echo "1. Review changes: git log --oneline -10"
echo "2. Test skill functionality"
echo "3. Create PR: gh pr create --fill"
echo "4. Merge after approval"
echo ""
echo "Rollback if needed:"
echo "  git checkout main && git branch -D $BRANCH"
echo "  cp -r $BACKUP_DIR/* .claude/skills/"

# Pre-execution backup
BACKUP_DIR=".claude/skills-backup-$(date +%Y%m%d-%H%M%S)"
cp -r .claude/skills "$BACKUP_DIR/"

# Git stash backup
git stash push -u -m "Pre-consolidation skills state"

# Registry backup
cp .claude/config/skills.json "$BACKUP_DIR/skills-backup.json"

# Method 1: Git branch deletion
git checkout main
git branch -D skills/consolidation-YYYYMMDD

# Method 2: Restore from backup
rm -rf .claude/skills
cp -r .claude/skills-backup-YYYYMMDD/skills .claude/skills/
git add .claude/skills/
git commit -m "Rollback: restore skills from backup"

# Rollback specific commits
git revert <commit-hash>

# Restore specific skills from backup
cp .claude/skills-backup-YYYYMMDD/skills/specific-skill.md .claude/skills/

# .claude/skills-manager-config.yml
conservatism_level: balanced  # Options: aggressive, balanced, conservative

protected_skills:
  - skill-creator-doctor
  - skills-manager
  - dev-debugging
  - basic-coding
  - git-workflow-helper
  - file-operations

risk_settings:
  max_deletion_risk: medium    # disallow high-risk deletion without manual confirmation
  merge_threshold: 0.7         # 70% overlap required for merge suggestion
  archive_instead_of_delete: true
  require_confirmation_for:
    - delete
    - merge
    - modify_protected

usage_analysis:
  usage_window_days: 90        # Analyze skill activations from last 90 days
  inactive_threshold: 180      # Days without usage before considering archive
  high_usage_threshold: 20     # Uses per 90 days = high usage

redundancy_detection:
  capability_similarity_threshold: 0.8
  trigger_conflict_detection: true
  semantic_analysis_enabled: true

output:
  generate_reports: true
  create_backup: true
  verbose_logging: false

# Update conservatism level
/skills-config --conservatism conservative

# Add protected skill
/skills-config --protect new-important-skill

# Adjust thresholds
/skills-config --merge-threshold 0.85

User: "/skills-audit"

System Response:
🔍 Running comprehensive skills audit...

=== System Analysis ===
Project: Vue.js TypeScript Application
Key Technologies: Vue 3, TypeScript, Pinia, Tailwind CSS
Relevance Domains: frontend, vue.js, typescript, productivity

=== Skills Inventory ===
Total Skills: 47
Categories: debug(12), create(8), fix(15), optimize(5), meta(7)

=== Usage Analysis ===
High Usage (20+): vue-debugging(23), dev-fix-timer(18)
Medium Usage (5-19): pinia-fixer(15), component-debugger(12)
Low Usage (1-4): old-webpack-configurator(1)
No Usage: legacy-skill(0), obsolete-helper(0)

=== Recommendations ===
5 skills ready for consolidation
3 skills candidates for archival
2 potential trigger conflicts identified

Generated detailed report: .claude/skills-audit-report-20251123.md

User: "/skills-consolidate"

System Response:
📋 Skills Consolidation Plan Generated

=== Executive Summary ===
- Current skills: 47 → Proposed: 32 (32% reduction)
- High priority actions: 5 (3 merges, 2 archives)
- Risk level: Medium (with backups available)

=== Proposed Actions ===

1. MERGE: component-debugger + vue-component-debugger → vue-debugging
   Similarity: 92% | Usage: vue-debugging 3x higher | Risk: LOW
   Rationale: High capability overlap, vue-debugging more actively used

2. ARCHIVE: old-webpack-configurator
   Last used: 210+ days ago | Obsolete webpack v3 references | Risk: LOW
   Rationale: No recent usage, superseded by modern tools

=== Protected Skills (Will NOT be modified) ===
- skill-creator-doctor (meta-skill)
- dev-debugging (core functionality)
- basic-coding (fundamental capability)

=== Safety Measures ===
✅ Backup will be created: .claude/skills-backup-20251123/
✅ Working branch: skills/consolidation-20251123
✅ Rollback available via git revert or backup restore

Proceed with consolidation? (y/n/view details):

User: "/skills-merge react-component-builder ui-generator"

System Response:
🔍 Analyzing skills for merge...

=== Skill Analysis ===
react-component-builder:
- Capabilities: Build React components, TypeScript support
- Usage: 8 times in last 90 days
- Last used: 2025-11-15

ui-generator:
- Capabilities: Generate UI components, styling options
- Usage: 5 times in last 90 days
- Last used: 2025-11-10

=== Similarity Analysis ===
Capability Overlap: 76%
Shared Features: Component generation, TypeScript support
Unique Features:
  - react-component-builder: React-specific hooks
  - ui-generator: Multiple styling frameworks

=== Merge Recommendation ===
Confidence: 82% | Risk: MEDIUM
Proposed Name: component-generator
Strategy: Combine capabilities with React-specific options

Proceed with merge? (y/n/customize):

"I've implemented [description of fix]. Before I mark this as complete, please verify:
1. [Specific thing to check #1]
2. [Specific thing to check #2]
3. Does this fix the issue you were experiencing?

Please confirm the fix works as expected, or let me know what's still not working."