fraim-framework 2.0.64 → 2.0.65

package/registry/scripts/interactive-explorer.py

@@ -1,270 +0,0 @@
-#!/usr/bin/env python3
-"""
-Interactive site explorer using Playwright
-Navigates through the site, clicks buttons, and captures screenshots
-
-Usage:
-    python interactive_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 SiteInteractor:
-    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_visited = []
-        self.actions_taken = []
-    
-    async def take_screenshot(self, page, name, description=""):
-        """Take a screenshot and save it"""
-        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)
-        self.pages_visited.append({
-            'name': name,
-            'filename': str(filename),
-            'url': page.url,
-            'description': description,
-            'timestamp': timestamp
-        })
-        print(f"  📸 Screenshot: {filename.name} - {description}")
-        return str(filename)
-    
-    async def wait_for_react(self, page):
-        """Wait for React to finish loading"""
-        try:
-            await page.wait_for_selector('#root', state='attached', timeout=5000)
-            await page.wait_for_timeout(2000)
-            content = await page.evaluate('''() => {
-                const root = document.getElementById('root');
-                return root && root.children.length > 0;
-            }''')
-            if not content:
-                await page.wait_for_timeout(3000)
-        except Exception as e:
-            print(f"  ⚠️  React loading check: {e}")
-    
-    async def analyze_page_content(self, page):
-        """Analyze the current page content"""
-        content = await page.evaluate('''() => {
-            return {
-                title: document.title,
-                url: window.location.href,
-                headings: {
-                    h1: Array.from(document.querySelectorAll('h1')).map(h => h.innerText.trim()),
-                    h2: Array.from(document.querySelectorAll('h2')).map(h => h.innerText.trim()),
-                    h3: Array.from(document.querySelectorAll('h3')).map(h => h.innerText.trim()),
-                },
-                buttons: Array.from(document.querySelectorAll('button, [role="button"], a[href]'))
-                    .filter(el => el.offsetParent !== null)
-                    .map(el => el.innerText.trim())
-                    .filter(text => text.length > 0),
-                links: Array.from(document.querySelectorAll('a[href]'))
-                    .map(a => ({text: a.innerText.trim(), href: a.href}))
-                    .filter(link => link.text.length > 0),
-                forms: Array.from(document.querySelectorAll('form')).length,
-                inputs: Array.from(document.querySelectorAll('input, textarea, select'))
-                    .map(input => ({
-                        type: input.type || input.tagName.toLowerCase(),
-                        name: input.name || '',
-                        placeholder: input.placeholder || '',
-                        id: input.id || ''
-                    })),
-                visible_text: document.body.innerText.substring(0, 1000)
-            };
-        }''')
-        return content
-    
-    async def navigate_and_explore(self, page, max_clicks=20):
-        """Navigate through the site and explore all functionality"""
-        print(f"\n🌐 Navigating to {self.base_url}...")
-        await page.goto(self.base_url, wait_until='networkidle', timeout=30000)
-        await self.wait_for_react(page)
-        
-        # Screenshot of homepage
-        await self.take_screenshot(page, "01_homepage", "Initial homepage load")
-        
-        # Analyze homepage
-        homepage_content = await self.analyze_page_content(page)
-        print(f"\n📄 Homepage Analysis:")
-        print(f"   Title: {homepage_content['title']}")
-        print(f"   H1: {homepage_content['headings']['h1']}")
-        print(f"   Buttons found: {len(homepage_content['buttons'])}")
-        print(f"   Links found: {len(homepage_content['links'])}")
-        
-        # Try clicking navigation/links
-        clicked_urls = set([self.base_url])
-        click_count = 0
-        
-        # Get all links
-        links = await page.query_selector_all('a[href], button, [role="button"]')
-        
-        for i, link in enumerate(links[:max_clicks]):
-            try:
-                if click_count >= max_clicks:
-                    break
-                
-                is_visible = await link.is_visible()
-                if not is_visible:
-                    continue
-                
-                tag_name = await link.evaluate('el => el.tagName.toLowerCase()')
-                text = await link.inner_text()
-                href = await link.get_attribute('href') if tag_name == 'a' else None
-                
-                if not text.strip() and not href:
-                    continue
-                
-                print(f"\n  🖱️  Clicking: {text[:50] if text else 'Link'} (tag: {tag_name})")
-                
-                # Take screenshot before click
-                await self.take_screenshot(
-                    page, 
-                    f"02_before_click_{click_count+1}", 
-                    f"Before clicking: {text[:30]}"
-                )
-                
-                # Click the element
-                try:
-                    if tag_name == 'a':
-                        await link.click(timeout=5000)
-                    else:
-                        await link.click(timeout=5000)
-                    
-                    click_count += 1
-                    await page.wait_for_timeout(3000)
-                    
-                    # Check if URL changed
-                    current_url = page.url
-                    if current_url not in clicked_urls:
-                        clicked_urls.add(current_url)
-                        await self.take_screenshot(
-                            page,
-                            f"03_after_click_{click_count}",
-                            f"After clicking: {text[:30]} - URL: {current_url}"
-                        )
-                        
-                        # Analyze new page
-                        new_content = await self.analyze_page_content(page)
-                        print(f"     📄 New page: {new_content['title']}")
-                        
-                        # Try to fill forms if present
-                        if new_content['forms'] > 0 or len(new_content['inputs']) > 0:
-                            print(f"     📝 Forms/inputs found: {len(new_content['inputs'])}")
-                            await self.take_screenshot(
-                                page,
-                                f"04_form_page_{click_count}",
-                                f"Page with forms/inputs"
-                            )
-                    
-                except Exception as e:
-                    print(f"     ⚠️  Click failed: {e}")
-                    try:
-                        await page.keyboard.press('Escape')
-                        await page.wait_for_timeout(1000)
-                    except:
-                        pass
-                
-            except Exception as e:
-                print(f"  ⚠️  Error processing link {i}: {e}")
-                continue
-        
-        # Final screenshot
-        await self.take_screenshot(page, "99_final_state", "Final state after exploration")
-    
-    async def identify_use_cases(self, page):
-        """Identify use cases from the site content"""
-        print("\n🔍 Identifying use cases...")
-        
-        all_text = await page.evaluate('''() => {
-            return document.body.innerText;
-        }''')
-        
-        use_case_keywords = {
-            'Event Management': ['event', 'calendar', 'schedule', 'meeting', 'workshop'],
-            'Field Assessment': ['assessment', 'field', 'survey', 'evaluation', 'inspection'],
-            'Species Management': ['species', 'invasive', 'native', 'wildlife', 'plant'],
-            'Data Collection': ['form', 'submit', 'upload', 'data', 'record'],
-            'Search & Discovery': ['search', 'find', 'filter', 'browse', 'discover'],
-            'Reporting': ['report', 'download', 'export', 'generate', 'print'],
-            'User Account': ['login', 'sign in', 'register', 'profile', 'account'],
-            'Map & Location': ['map', 'location', 'coordinates', 'gps', 'area'],
-            'Education': ['learn', 'guide', 'tutorial', 'help', 'documentation'],
-            'Community': ['community', 'share', 'connect', 'network', 'collaborate']
-        }
-        
-        identified_use_cases = []
-        text_lower = all_text.lower()
-        
-        for use_case, keywords in use_case_keywords.items():
-            matches = sum(1 for keyword in keywords if keyword in text_lower)
-            if matches >= 2:
-                identified_use_cases.append({
-                    'use_case': use_case,
-                    'confidence': 'high' if matches >= 3 else 'medium',
-                    'keywords_found': [k for k in keywords if k in text_lower]
-                })
-        
-        self.use_cases = identified_use_cases
-        return identified_use_cases
-    
-    async def run_full_analysis(self, headless=True):
-        """Run the complete analysis"""
-        async with async_playwright() as p:
-            print("🚀 Starting browser...")
-            browser = await p.chromium.launch(headless=headless)
-            context = await browser.new_context(
-                viewport={'width': 1920, 'height': 1080}
-            )
-            page = await context.new_page()
-            
-            try:
-                await self.navigate_and_explore(page)
-                use_cases = await self.identify_use_cases(page)
-                
-                report = {
-                    'base_url': self.base_url,
-                    'analysis_date': datetime.now().isoformat(),
-                    'pages_visited': self.pages_visited,
-                    'use_cases': use_cases,
-                    'total_screenshots': len(self.pages_visited)
-                }
-                
-                output_path = self.output_dir / 'interaction_analysis.json'
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    json.dump(report, f, indent=2, ensure_ascii=False)
-                
-                print(f"\n✅ Analysis complete!")
-                print(f"   📸 Screenshots: {len(self.pages_visited)}")
-                print(f"   🎯 Use cases identified: {len(use_cases)}")
-                print(f"   💾 Report saved: {output_path}")
-                
-            finally:
-                await browser.close()
-
-async def main():
-    parser = argparse.ArgumentParser(description='Interactively explore a website with Playwright')
-    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')
-    parser.add_argument('--max-clicks', type=int, default=20, help='Maximum number of clicks to perform (default: 20)')
-    
-    args = parser.parse_args()
-    
-    interactor = SiteInteractor(args.url, args.output_dir)
-    await interactor.run_full_analysis(headless=args.headless)
-
-if __name__ == "__main__":
-    asyncio.run(main())

package/registry/scripts/markdown-to-pdf.js

@@ -1,395 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Markdown to PDF Converter Script
- * 
- * This script converts markdown files to PDF using puppeteer and markdown-it.
- * It supports various markdown features including tables, code blocks, and images.
- * 
- * EXECUTION MODEL:
- * - Script location: ~/.fraim/scripts/markdown-to-pdf.js
- * - Working directory: Current project directory (process.cwd())
- * - Input/output files: Relative to current project directory
- * - Config: Reads from .fraim/config.json in current project directory
- * 
- * Usage:
- *   node ~/.fraim/scripts/markdown-to-pdf.js <input.md> [output.pdf] [options]
- * 
- * Options:
- *   --format <format>     Paper format (A4, Letter, Legal, etc.) - default: A4
- *   --margin <margin>     Page margins in inches - default: 0.5
- *   --css <file>          Custom CSS file for styling
- *   --header <text>       Header text
- *   --footer <text>       Footer text
- *   --landscape           Use landscape orientation
- *   --no-background       Disable background graphics
- * 
- * Examples:
- *   node ~/.fraim/scripts/markdown-to-pdf.js README.md
- *   node ~/.fraim/scripts/markdown-to-pdf.js docs/spec.md output/spec.pdf --format Letter
- *   node ~/.fraim/scripts/markdown-to-pdf.js report.md --css custom.css --header "Company Report"
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Get project directory (where the user is working)
-const PROJECT_DIR = process.cwd();
-const CONFIG_FILE = path.join(PROJECT_DIR, '.fraim', 'config.json');
-
-// Load project configuration if available
-function loadProjectConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
-      return config;
-    }
-  } catch (error) {
-    console.warn('Warning: Could not load project config from .fraim/config.json');
-  }
-  return {};
-}
-
-// Check if required dependencies are available
-function checkDependencies() {
-  const requiredPackages = ['puppeteer', 'markdown-it', 'markdown-it-highlightjs'];
-  const missingPackages = [];
-
-  for (const pkg of requiredPackages) {
-    try {
-      require.resolve(pkg);
-    } catch (error) {
-      missingPackages.push(pkg);
-    }
-  }
-
-  if (missingPackages.length > 0) {
-    console.error('Missing required packages:', missingPackages.join(', '));
-    console.error('Install them with: npm install', missingPackages.join(' '));
-    return false;
-  }
-  return true;
-}
-
-// Parse command line arguments
-function parseArgs() {
-  const args = process.argv.slice(2);
-  
-  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
-    console.log(`
-Markdown to PDF Converter
-
-Usage: node ~/.fraim/scripts/markdown-to-pdf.js <input.md> [output.pdf] [options]
-
-Options:
-  --format <format>     Paper format (A4, Letter, Legal, etc.) - default: A4
-  --margin <margin>     Page margins in inches - default: 0.5
-  --css <file>          Custom CSS file for styling
-  --header <text>       Header text
-  --footer <text>       Footer text
-  --landscape           Use landscape orientation
-  --no-background       Disable background graphics
-  --help, -h            Show this help message
-
-Examples:
-  node ~/.fraim/scripts/markdown-to-pdf.js README.md
-  node ~/.fraim/scripts/markdown-to-pdf.js docs/spec.md output/spec.pdf --format Letter
-  node ~/.fraim/scripts/markdown-to-pdf.js report.md --css custom.css --header "Company Report"
-
-Working Directory: ${PROJECT_DIR}
-Config File: ${CONFIG_FILE}
-    `);
-    process.exit(0);
-  }
-
-  const config = {
-    input: args[0],
-    output: null,
-    format: 'A4',
-    margin: '0.5in',
-    css: null,
-    header: null,
-    footer: null,
-    landscape: false,
-    background: true
-  };
-
-  // Resolve input path relative to project directory
-  if (!path.isAbsolute(config.input)) {
-    config.input = path.resolve(PROJECT_DIR, config.input);
-  }
-
-  // Check if second argument is output file or option
-  if (args[1] && !args[1].startsWith('--')) {
-    config.output = args[1];
-  }
-
-  // Parse options
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    
-    if (arg === '--format' && args[i + 1]) {
-      config.format = args[i + 1];
-      i++;
-    } else if (arg === '--margin' && args[i + 1]) {
-      config.margin = args[i + 1];
-      i++;
-    } else if (arg === '--css' && args[i + 1]) {
-      config.css = args[i + 1];
-      i++;
-    } else if (arg === '--header' && args[i + 1]) {
-      config.header = args[i + 1];
-      i++;
-    } else if (arg === '--footer' && args[i + 1]) {
-      config.footer = args[i + 1];
-      i++;
-    } else if (arg === '--landscape') {
-      config.landscape = true;
-    } else if (arg === '--no-background') {
-      config.background = false;
-    }
-  }
-
-  // Set default output if not provided
-  if (!config.output) {
-    const inputPath = path.parse(config.input);
-    config.output = path.join(inputPath.dir, inputPath.name + '.pdf');
-  }
-
-  // Resolve output path relative to project directory
-  if (!path.isAbsolute(config.output)) {
-    config.output = path.resolve(PROJECT_DIR, config.output);
-  }
-
-  // Resolve CSS path relative to project directory if provided
-  if (config.css && !path.isAbsolute(config.css)) {
-    config.css = path.resolve(PROJECT_DIR, config.css);
-  }
-
-  return config;
-}
-
-// Convert markdown to HTML
-async function markdownToHtml(markdownContent, customCss = null) {
-  const MarkdownIt = require('markdown-it');
-  const hljs = require('markdown-it-highlightjs');
-  
-  const md = new MarkdownIt({
-    html: true,
-    linkify: true,
-    typographer: true,
-    breaks: false
-  }).use(hljs);
-
-  const htmlContent = md.render(markdownContent);
-  
-  // Default CSS for better PDF rendering
-  const defaultCss = `
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      line-height: 1.6;
-      color: #333;
-      max-width: none;
-      margin: 0;
-      padding: 20px;
-    }
-    
-    h1, h2, h3, h4, h5, h6 {
-      color: #2c3e50;
-      margin-top: 2em;
-      margin-bottom: 1em;
-    }
-    
-    h1 { font-size: 2.5em; border-bottom: 2px solid #3498db; padding-bottom: 0.3em; }
-    h2 { font-size: 2em; border-bottom: 1px solid #bdc3c7; padding-bottom: 0.3em; }
-    h3 { font-size: 1.5em; }
-    
-    code {
-      background-color: #f8f9fa;
-      padding: 2px 4px;
-      border-radius: 3px;
-      font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
-    }
-    
-    pre {
-      background-color: #f8f9fa;
-      border: 1px solid #e9ecef;
-      border-radius: 6px;
-      padding: 16px;
-      overflow-x: auto;
-      margin: 1em 0;
-    }
-    
-    pre code {
-      background: none;
-      padding: 0;
-    }
-    
-    table {
-      border-collapse: collapse;
-      width: 100%;
-      margin: 1em 0;
-    }
-    
-    th, td {
-      border: 1px solid #ddd;
-      padding: 12px;
-      text-align: left;
-    }
-    
-    th {
-      background-color: #f2f2f2;
-      font-weight: bold;
-    }
-    
-    blockquote {
-      border-left: 4px solid #3498db;
-      margin: 1em 0;
-      padding-left: 1em;
-      color: #7f8c8d;
-    }
-    
-    img {
-      max-width: 100%;
-      height: auto;
-    }
-    
-    a {
-      color: #3498db;
-      text-decoration: none;
-    }
-    
-    a:hover {
-      text-decoration: underline;
-    }
-    
-    ul, ol {
-      padding-left: 2em;
-    }
-    
-    li {
-      margin: 0.5em 0;
-    }
-    
-    @media print {
-      body { margin: 0; }
-      h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
-      pre, blockquote { page-break-inside: avoid; }
-      img { page-break-inside: avoid; }
-    }
-  `;
-  
-  let customCssContent = '';
-  if (customCss && fs.existsSync(customCss)) {
-    customCssContent = fs.readFileSync(customCss, 'utf8');
-  }
-  
-  return `
-    <!DOCTYPE html>
-    <html>
-    <head>
-      <meta charset="utf-8">
-      <title>Converted from Markdown</title>
-      <style>${defaultCss}${customCssContent}</style>
-    </head>
-    <body>
-      ${htmlContent}
-    </body>
-    </html>
-  `;
-}
-
-// Convert HTML to PDF using Puppeteer
-async function htmlToPdf(html, outputPath, config) {
-  const puppeteer = require('puppeteer');
-  
-  const browser = await puppeteer.launch({
-    headless: 'new',
-    args: ['--no-sandbox', '--disable-setuid-sandbox']
-  });
-  
-  try {
-    const page = await browser.newPage();
-    await page.setContent(html, { waitUntil: 'networkidle0' });
-    
-    const pdfOptions = {
-      path: outputPath,
-      format: config.format,
-      margin: {
-        top: config.margin,
-        right: config.margin,
-        bottom: config.margin,
-        left: config.margin
-      },
-      landscape: config.landscape,
-      printBackground: config.background,
-      preferCSSPageSize: true
-    };
-    
-    if (config.header) {
-      pdfOptions.displayHeaderFooter = true;
-      pdfOptions.headerTemplate = `<div style="font-size: 10px; width: 100%; text-align: center;">${config.header}</div>`;
-    }
-    
-    if (config.footer) {
-      pdfOptions.displayHeaderFooter = true;
-      pdfOptions.footerTemplate = `<div style="font-size: 10px; width: 100%; text-align: center;">${config.footer}</div>`;
-    }
-    
-    await page.pdf(pdfOptions);
-    console.log(`✅ PDF generated successfully: ${path.relative(PROJECT_DIR, outputPath)}`);
-    
-  } finally {
-    await browser.close();
-  }
-}
-
-// Main function
-async function main() {
-  try {
-    if (!checkDependencies()) {
-      process.exit(1);
-    }
-    
-    const config = parseArgs();
-    const projectConfig = loadProjectConfig();
-    
-    console.log(`📄 Converting markdown to PDF...`);
-    console.log(`   Working directory: ${PROJECT_DIR}`);
-    console.log(`   Input: ${path.relative(PROJECT_DIR, config.input)}`);
-    console.log(`   Output: ${path.relative(PROJECT_DIR, config.output)}`);
-    
-    // Validate input file
-    if (!fs.existsSync(config.input)) {
-      console.error(`❌ Input file not found: ${path.relative(PROJECT_DIR, config.input)}`);
-      process.exit(1);
-    }
-    
-    // Ensure output directory exists
-    const outputDir = path.dirname(config.output);
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-      console.log(`📁 Created output directory: ${path.relative(PROJECT_DIR, outputDir)}`);
-    }
-    
-    // Read markdown file
-    const markdownContent = fs.readFileSync(config.input, 'utf8');
-    
-    // Convert to HTML
-    const html = await markdownToHtml(markdownContent, config.css);
-    
-    // Convert to PDF
-    await htmlToPdf(html, config.output, config);
-    
-  } catch (error) {
-    console.error('❌ Error:', error.message);
-    process.exit(1);
-  }
-}
-
-// Run if called directly
-if (require.main === module) {
-  main();
-}
-
-module.exports = { markdownToHtml, htmlToPdf, parseArgs, checkDependencies };