fraim-framework 2.0.64 → 2.0.65

package/registry/scripts/comprehensive-explorer.py

@@ -1,297 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive site exploration - deep dive into all pages and functionality
-
-Usage:
-    python comprehensive_explorer.py <base_url> [--output-dir DIR] [--headless]
-"""
-
-import asyncio
-from playwright.async_api import async_playwright
-import json
-import os
-import sys
-import argparse
-from datetime import datetime
-from pathlib import Path
-
-class ComprehensiveExplorer:
-    def __init__(self, base_url, output_dir="."):
-        self.base_url = base_url
-        self.output_dir = Path(output_dir)
-        self.screenshots_dir = self.output_dir / "screenshots"
-        self.screenshots_dir.mkdir(parents=True, exist_ok=True)
-        
-        self.use_cases = []
-        self.pages_data = []
-        self.all_text_content = []
-    
-    async def take_screenshot(self, page, name, description=""):
-        """Take a screenshot"""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = self.screenshots_dir / f"{name}_{timestamp}.png"
-        await page.screenshot(path=str(filename), full_page=True)
-        return str(filename)
-    
-    async def extract_page_content(self, page, page_name):
-        """Extract comprehensive content from a page"""
-        content = await page.evaluate('''() => {
-            const getText = (el) => el ? el.innerText.trim() : '';
-            
-            return {
-                url: window.location.href,
-                title: document.title,
-                headings: {
-                    h1: Array.from(document.querySelectorAll('h1')).map(h => h.innerText.trim()).filter(t => t),
-                    h2: Array.from(document.querySelectorAll('h2')).map(h => h.innerText.trim()).filter(t => t),
-                    h3: Array.from(document.querySelectorAll('h3')).map(h => h.innerText.trim()).filter(t => t),
-                },
-                buttons: Array.from(document.querySelectorAll('button, [role="button"]'))
-                    .filter(el => el.offsetParent !== null)
-                    .map(el => el.innerText.trim())
-                    .filter(t => t.length > 0)
-                    .slice(0, 20),
-                links: Array.from(document.querySelectorAll('a[href]'))
-                    .filter(el => el.offsetParent !== null)
-                    .map(a => ({
-                        text: a.innerText.trim(),
-                        href: a.href
-                    }))
-                    .filter(link => link.text.length > 0 || link.href)
-                    .slice(0, 30),
-                forms: Array.from(document.querySelectorAll('form')).map((form, idx) => ({
-                    index: idx,
-                    action: form.action || '',
-                    method: form.method || 'GET',
-                    inputs: Array.from(form.querySelectorAll('input, textarea, select')).map(input => ({
-                        type: input.type || input.tagName.toLowerCase(),
-                        name: input.name || '',
-                        placeholder: input.placeholder || '',
-                        id: input.id || '',
-                        label: (() => {
-                            const label = document.querySelector(`label[for="${input.id}"]`);
-                            return label ? label.innerText.trim() : '';
-                        })()
-                    }))
-                })),
-                sections: Array.from(document.querySelectorAll('section, [class*="section"], [class*="Section"]'))
-                    .map(section => section.innerText.trim().substring(0, 200))
-                    .filter(t => t.length > 0)
-                    .slice(0, 10),
-                main_text: document.body.innerText.substring(0, 5000),
-                images: Array.from(document.querySelectorAll('img[src]'))
-                    .map(img => img.src || img.getAttribute('src'))
-                    .filter(src => src)
-                    .slice(0, 10)
-            };
-        }''')
-        
-        return content
-    
-    async def explore_route(self, page, route, page_name):
-        """Explore a specific route"""
-        try:
-            url = f"{self.base_url}{route}" if route.startswith('/') else f"{self.base_url}/{route}"
-            print(f"  🔍 Exploring: {url}")
-            
-            await page.goto(url, wait_until='networkidle', timeout=30000)
-            await page.wait_for_timeout(3000)
-            
-            content = await self.extract_page_content(page, page_name)
-            self.all_text_content.append(content['main_text'])
-            
-            screenshot = await self.take_screenshot(page, page_name, f"Page: {page_name}")
-            
-            page_data = {
-                'name': page_name,
-                'url': content['url'],
-                'title': content['title'],
-                'headings': content['headings'],
-                'buttons': content['buttons'],
-                'links': content['links'],
-                'forms': content['forms'],
-                'sections': content['sections'],
-                'screenshot': screenshot,
-                'main_text': content['main_text'][:1000]
-            }
-            
-            self.pages_data.append(page_data)
-            print(f"     ✅ Found {len(content['headings']['h1'])} H1, {len(content['buttons'])} buttons, {len(content['forms'])} forms")
-            
-            return page_data
-            
-        except Exception as e:
-            print(f"     ⚠️  Error exploring {route}: {e}")
-            return None
-    
-    async def discover_routes_from_homepage(self, page):
-        """Discover routes by analyzing the homepage"""
-        await page.goto(self.base_url, wait_until='networkidle', timeout=30000)
-        await page.wait_for_timeout(3000)
-        
-        links = await page.evaluate(f'''() => {{
-            const baseUrl = "{self.base_url}";
-            return Array.from(document.querySelectorAll('a[href]'))
-                .map(a => a.href)
-                .filter(href => href && href.includes(baseUrl))
-                .map(href => {{
-                    const url = new URL(href);
-                    return url.pathname;
-                }})
-                .filter(path => path && path !== '/')
-                .filter((v, i, a) => a.indexOf(v) === i);
-        }}''')
-        
-        print(f"\n🔗 Discovered {len(links)} unique routes from homepage")
-        return links
-    
-    async def explore_all_routes(self, page):
-        """Explore common routes and discovered routes"""
-        common_routes = [
-            '/', '/home', '/events', '/event', '/signup', '/sign-up',
-            '/login', '/signin', '/sign-in', '/dashboard', '/profile',
-            '/about', '/contact', '/help', '/faq', '/map',
-            '/assessments', '/assessment', '/field', '/species',
-            '/organizations', '/organization', '/volunteer', '/volunteers',
-            '/community', '/hub'
-        ]
-        
-        print("\n📍 Exploring common routes...")
-        for route in common_routes:
-            page_name = route.replace('/', '').replace('-', '_') or 'home'
-            await self.explore_route(page, route, page_name)
-            await asyncio.sleep(1)
-    
-    async def identify_use_cases_comprehensive(self):
-        """Comprehensively identify use cases from all collected content"""
-        print("\n🎯 Analyzing use cases from collected content...")
-        
-        all_text = ' '.join(self.all_text_content).lower()
-        
-        use_case_patterns = {
-            'Event Discovery & Registration': {
-                'keywords': ['event', 'calendar', 'schedule', 'upcoming', 'register', 'rsvp', 'workshop', 'meeting', 'volunteer event'],
-                'evidence': []
-            },
-            'Field Assessment & Data Collection': {
-                'keywords': ['assessment', 'field', 'survey', 'evaluation', 'inspection', 'data collection', 'record', 'observation'],
-                'evidence': []
-            },
-            'Invasive Species Management': {
-                'keywords': ['invasive', 'species', 'native', 'wildlife', 'plant', 'management', 'control', 'removal'],
-                'evidence': []
-            },
-            'Organization & Community Management': {
-                'keywords': ['organization', 'community', 'hub', 'group', 'network', 'connect', 'collaborate'],
-                'evidence': []
-            },
-            'User Account & Authentication': {
-                'keywords': ['sign up', 'sign in', 'login', 'register', 'account', 'profile', 'user'],
-                'evidence': []
-            },
-            'Search & Filter': {
-                'keywords': ['search', 'find', 'filter', 'browse', 'discover', 'explore'],
-                'evidence': []
-            },
-            'Reporting & Data Export': {
-                'keywords': ['report', 'download', 'export', 'generate', 'print', 'data'],
-                'evidence': []
-            },
-            'Map & Location Services': {
-                'keywords': ['map', 'location', 'coordinates', 'gps', 'area', 'region', 'geographic'],
-                'evidence': []
-            },
-            'Educational Resources': {
-                'keywords': ['learn', 'guide', 'tutorial', 'help', 'documentation', 'faq', 'frequently asked'],
-                'evidence': []
-            },
-            'Volunteer Management': {
-                'keywords': ['volunteer', 'volunteers', 'participation', 'contribute', 'join'],
-                'evidence': []
-            }
-        }
-        
-        for use_case, data in use_case_patterns.items():
-            for keyword in data['keywords']:
-                if keyword in all_text:
-                    data['evidence'].append(keyword)
-        
-        identified_use_cases = []
-        for use_case, data in use_case_patterns.items():
-            if len(data['evidence']) >= 2:
-                confidence = 'high' if len(data['evidence']) >= 4 else 'medium' if len(data['evidence']) >= 3 else 'low'
-                identified_use_cases.append({
-                    'use_case': use_case,
-                    'confidence': confidence,
-                    'evidence_count': len(data['evidence']),
-                    'keywords_found': data['evidence'][:10]
-                })
-        
-        identified_use_cases.sort(key=lambda x: x['evidence_count'], reverse=True)
-        self.use_cases = identified_use_cases
-        return identified_use_cases
-    
-    async def run_comprehensive_analysis(self, headless=True):
-        """Run the complete comprehensive analysis"""
-        async with async_playwright() as p:
-            print("🚀 Starting comprehensive browser analysis...")
-            browser = await p.chromium.launch(headless=headless)
-            context = await browser.new_context(
-                viewport={'width': 1920, 'height': 1080},
-                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-            )
-            page = await context.new_page()
-            
-            try:
-                discovered_routes = await self.discover_routes_from_homepage(page)
-                await self.explore_route(page, '/', 'homepage')
-                
-                print(f"\n📍 Exploring {len(discovered_routes)} discovered routes...")
-                for route in discovered_routes[:15]:
-                    page_name = route.replace('/', '').replace('-', '_') or 'home'
-                    await self.explore_route(page, route, page_name)
-                    await asyncio.sleep(1)
-                
-                await self.explore_all_routes(page)
-                use_cases = await self.identify_use_cases_comprehensive()
-                
-                report = {
-                    'base_url': self.base_url,
-                    'analysis_date': datetime.now().isoformat(),
-                    'pages_analyzed': len(self.pages_data),
-                    'pages': self.pages_data,
-                    'use_cases': use_cases,
-                    'discovered_routes': discovered_routes,
-                    'total_screenshots': len(self.pages_data)
-                }
-                
-                output_path = self.output_dir / 'comprehensive_analysis.json'
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    json.dump(report, f, indent=2, ensure_ascii=False)
-                
-                print(f"\n✅ Comprehensive analysis complete!")
-                print(f"   📄 Pages analyzed: {len(self.pages_data)}")
-                print(f"   📸 Screenshots: {len(self.pages_data)}")
-                print(f"   🎯 Use cases identified: {len(use_cases)}")
-                print(f"   💾 Report saved: {output_path}")
-                
-                print(f"\n📋 Identified Use Cases:")
-                for uc in use_cases:
-                    print(f"   • {uc['use_case']} ({uc['confidence']} confidence, {uc['evidence_count']} evidence)")
-                
-            finally:
-                await browser.close()
-
-async def main():
-    parser = argparse.ArgumentParser(description='Comprehensively explore a website')
-    parser.add_argument('url', help='Base URL of the website to explore')
-    parser.add_argument('--output-dir', default='.', help='Output directory for results (default: current directory)')
-    parser.add_argument('--headless', action='store_true', help='Run browser in headless mode')
-    
-    args = parser.parse_args()
-    
-    explorer = ComprehensiveExplorer(args.url, args.output_dir)
-    await explorer.run_comprehensive_analysis(headless=args.headless)
-
-if __name__ == "__main__":
-    asyncio.run(main())

package/registry/scripts/create-git-labels.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-
-# Create GitHub labels from JSON file
-# Usage: ./create-git-labels.sh labels.json
-
-if [ $# -eq 0 ]; then
-    echo "Usage: $0 <labels.json>"
-    exit 1
-fi
-
-LABELS_FILE="$1"
-
-if [ ! -f "$LABELS_FILE" ]; then
-    echo "Error: $LABELS_FILE not found"
-    exit 1
-fi
-
-echo "🏷️  Creating GitHub labels from $LABELS_FILE..."
-
-# Check if gh CLI is available
-if ! command -v gh &> /dev/null; then
-    echo "❌ GitHub CLI (gh) not found. Please install it first:"
-    echo "   https://cli.github.com/"
-    echo "   Then run: gh auth login"
-    exit 1
-fi
-
-# Check if user is authenticated
-if ! gh auth status &> /dev/null; then
-    echo "❌ Not authenticated with GitHub. Please run:"
-    echo "   gh auth login"
-    exit 1
-fi
-
-# Parse JSON and create labels
-node -e "
-const fs = require('fs');
-const labels = JSON.parse(fs.readFileSync('$LABELS_FILE', 'utf8'));
-
-labels.forEach(label => {
-  const command = \`gh label create \\\"\${label.name}\\\" --color \\\"\${label.color}\\\" --description \\\"\${label.description}\\\"\`;
-  console.log(command);
-});
-" | while read -r command; do
-    echo "  Executing: $command"
-    eval "$command" || echo "    ⚠️  Label might already exist"
-done
-
-echo "✅ GitHub labels creation complete!"