@amrhas82/agentic-kit 1.7.0 → 1.7.6

package/packages/droid/commands/webapp-testing/examples/element_discovery.py

@@ -1,40 +0,0 @@
-from playwright.sync_api import sync_playwright
-
-# Example: Discovering buttons and other elements on a page
-
-with sync_playwright() as p:
-    browser = p.chromium.launch(headless=True)
-    page = browser.new_page()
-
-    # Navigate to page and wait for it to fully load
-    page.goto('http://localhost:5173')
-    page.wait_for_load_state('networkidle')
-
-    # Discover all buttons on the page
-    buttons = page.locator('button').all()
-    print(f"Found {len(buttons)} buttons:")
-    for i, button in enumerate(buttons):
-        text = button.inner_text() if button.is_visible() else "[hidden]"
-        print(f"  [{i}] {text}")
-
-    # Discover links
-    links = page.locator('a[href]').all()
-    print(f"\nFound {len(links)} links:")
-    for link in links[:5]:  # Show first 5
-        text = link.inner_text().strip()
-        href = link.get_attribute('href')
-        print(f"  - {text} -> {href}")
-
-    # Discover input fields
-    inputs = page.locator('input, textarea, select').all()
-    print(f"\nFound {len(inputs)} input fields:")
-    for input_elem in inputs:
-        name = input_elem.get_attribute('name') or input_elem.get_attribute('id') or "[unnamed]"
-        input_type = input_elem.get_attribute('type') or 'text'
-        print(f"  - {name} ({input_type})")
-
-    # Take screenshot for visual reference
-    page.screenshot(path='/tmp/page_discovery.png', full_page=True)
-    print("\nScreenshot saved to /tmp/page_discovery.png")
-
-    browser.close()

package/packages/droid/commands/webapp-testing/examples/static_html_automation.py

@@ -1,33 +0,0 @@
-from playwright.sync_api import sync_playwright
-import os
-
-# Example: Automating interaction with static HTML files using file:// URLs
-
-html_file_path = os.path.abspath('path/to/your/file.html')
-file_url = f'file://{html_file_path}'
-
-with sync_playwright() as p:
-    browser = p.chromium.launch(headless=True)
-    page = browser.new_page(viewport={'width': 1920, 'height': 1080})
-
-    # Navigate to local HTML file
-    page.goto(file_url)
-
-    # Take screenshot
-    page.screenshot(path='/mnt/user-data/outputs/static_page.png', full_page=True)
-
-    # Interact with elements
-    page.click('text=Click Me')
-    page.fill('#name', 'John Doe')
-    page.fill('#email', 'john@example.com')
-
-    # Submit form
-    page.click('button[type="submit"]')
-    page.wait_for_timeout(500)
-
-    # Take final screenshot
-    page.screenshot(path='/mnt/user-data/outputs/after_submit.png', full_page=True)
-
-    browser.close()
-
-print("Static HTML automation completed!")

package/packages/droid/commands/webapp-testing/scripts/with_server.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Start one or more servers, wait for them to be ready, run a command, then clean up.
-
-Usage:
-    # Single server
-    python scripts/with_server.py --server "npm run dev" --port 5173 -- python automation.py
-    python scripts/with_server.py --server "npm start" --port 3000 -- python test.py
-
-    # Multiple servers
-    python scripts/with_server.py \
-      --server "cd backend && python server.py" --port 3000 \
-      --server "cd frontend && npm run dev" --port 5173 \
-      -- python test.py
-"""
-
-import subprocess
-import socket
-import time
-import sys
-import argparse
-
-def is_server_ready(port, timeout=30):
-    """Wait for server to be ready by polling the port."""
-    start_time = time.time()
-    while time.time() - start_time < timeout:
-        try:
-            with socket.create_connection(('localhost', port), timeout=1):
-                return True
-        except (socket.error, ConnectionRefusedError):
-            time.sleep(0.5)
-    return False
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Run command with one or more servers')
-    parser.add_argument('--server', action='append', dest='servers', required=True, help='Server command (can be repeated)')
-    parser.add_argument('--port', action='append', dest='ports', type=int, required=True, help='Port for each server (must match --server count)')
-    parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds per server (default: 30)')
-    parser.add_argument('command', nargs=argparse.REMAINDER, help='Command to run after server(s) ready')
-
-    args = parser.parse_args()
-
-    # Remove the '--' separator if present
-    if args.command and args.command[0] == '--':
-        args.command = args.command[1:]
-
-    if not args.command:
-        print("Error: No command specified to run")
-        sys.exit(1)
-
-    # Parse server configurations
-    if len(args.servers) != len(args.ports):
-        print("Error: Number of --server and --port arguments must match")
-        sys.exit(1)
-
-    servers = []
-    for cmd, port in zip(args.servers, args.ports):
-        servers.append({'cmd': cmd, 'port': port})
-
-    server_processes = []
-
-    try:
-        # Start all servers
-        for i, server in enumerate(servers):
-            print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
-
-            # Use shell=True to support commands with cd and &&
-            process = subprocess.Popen(
-                server['cmd'],
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            server_processes.append(process)
-
-            # Wait for this server to be ready
-            print(f"Waiting for server on port {server['port']}...")
-            if not is_server_ready(server['port'], timeout=args.timeout):
-                raise RuntimeError(f"Server failed to start on port {server['port']} within {args.timeout}s")
-
-            print(f"Server ready on port {server['port']}")
-
-        print(f"\nAll {len(servers)} server(s) ready")
-
-        # Run the command
-        print(f"Running: {' '.join(args.command)}\n")
-        result = subprocess.run(args.command)
-        sys.exit(result.returncode)
-
-    finally:
-        # Clean up all servers
-        print(f"\nStopping {len(server_processes)} server(s)...")
-        for i, process in enumerate(server_processes):
-            try:
-                process.terminate()
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                process.kill()
-                process.wait()
-            print(f"Server {i+1} stopped")
-        print("All servers stopped")
-
-
-if __name__ == '__main__':
-    main()

package/packages/droid/commands/webapp-testing/webapp-testing.md

@@ -1,275 +0,0 @@
----
-description: Test local web applications using Playwright - verify functionality, debug UI, capture screenshots
-argument-hint: <webapp-url-or-local-server>
----
-
-Test local web applications using native Python Playwright scripts with bundled helper utilities.
-
-## Available Operations
-
-- `static` - Test static HTML files
-- `dynamic` - Test dynamic web applications  
-- `debug` - Debug UI behavior and capture logs
-- `screenshot` - Capture browser screenshots
-- `server` - Manage server lifecycle for testing
-
-## Decision Tree
-
-```
-Task → Is it static HTML?
-    ├─ Yes → Read HTML file directly to identify selectors
-    │         ├─ Success → Write Playwright script using selectors
-    │         └─ Fails/Incomplete → Treat as dynamic (below)
-    │
-    └─ No (dynamic webapp) → Is the server already running?
-        ├─ No → Run: python scripts/with_server.py --help
-        │        Then use the helper + write simplified Playwright script
-        │
-        └─ Yes → Reconnaissance-then-action:
-            1. Navigate and wait for networkidle
-            2. Take screenshot or inspect DOM
-            3. Identify selectors from rendered state
-            4. Execute actions with discovered selectors
-```
-
-## Basic Playwright Setup
-
-```python
-from playwright.sync_api import sync_playwright
-
-with sync_playwright() as p:
-    browser = p.chromium.launch(headless=True)  # Always chromium in headless
-    page = browser.new_page()
-    page.goto('http://localhost:5173')  # Your local server
-    page.wait_for_load_state('networkidle')  # CRITICAL: Wait for JS execution
-    
-    # Your automation logic here
-    
-    browser.close()
-```
-
-## Server Management with with_server.py
-
-**Single server:**
-```bash
-python scripts/with_server.py \
-  --server "npm run dev" \
-  --port 5173 \
-  -- python your_automation.py
-```
-
-**Multiple servers (backend + frontend):**
-```bash
-python scripts/with_server.py \
-  --server "cd backend && python server.py" --port 3000 \
-  --server "cd frontend && npm run dev" --port 5173 \
-  -- python your_automation.py
-```
-
-**Always run `--help` first:**
-```bash
-python scripts/with_server.py --help
-```
-
-## Reconnaissance-Then-Action Pattern
-
-### 1. Inspect Rendered DOM
-```python
-# Take full page screenshot
-page.screenshot(path='/tmp/inspect.png', full_page=True)
-
-# Get page content
-content = page.content()
-
-# Discover all buttons, links, inputs
-page.locator('button').all()
-page.locator('a').all() 
-page.locator('input').all()
-```
-
-### 2. Identify Selectors
-Common selector strategies:
-- **Text-based**: `page.locator('text=Login')`
-- **Role-based**: `page.locator('role=button')`
-- **CSS selectors**: `page.locator('.button-primary')`
-- **IDs**: `page.locator('#submit-form')`
-
-### 3. Execute Actions
-```python
-# Click elements
-page.click('button:has-text("Submit")')
-
-# Fill forms
-page.fill('input[name="email"]', 'user@example.com')
-page.fill('input[type="password"]', 'password123')
-
-# Select from dropdown
-page.select_option('select[name="country"]', 'US')
-
-# Wait for elements
-page.wait_for_selector('.loading-spinner', state='hidden')
-```
-
-## Common Patterns
-
-### Form Interaction
-```python
-# Complete multi-step form
-page.goto('http://localhost:3000/form')
-page.wait_for_load_state('networkidle')
-
-# Fill form fields
-page.fill('input[name="firstName"]', 'John')
-page.fill('input[name="lastName"]', 'Doe')
-page.fill('input[name="email"]', 'john.doe@example.com')
-
-# Select dropdown
-page.select_option('select[name="country"]', 'United States')
-
-# Submit form
-page.click('button[type="submit"]')
-
-# Verify success
-page.wait_for_selector('.success-message')
-assert page.locator('.success-message').text_content() == 'Form submitted successfully!'
-```
-
-### Navigation Testing
-```python
-# Test navigation between pages
-page.click('a[href="/dashboard"]')
-page.wait_for_load_state('networkidle')
-
-# Verify URL changed
-assert page.url == 'http://localhost:3000/dashboard'
-
-# Check page content
-assert page.locator('h1:has-text("Dashboard")').is_visible()
-```
-
-### Data Loading and Waiting
-```python
-# Wait for data to load
-page.wait_for_selector('.data-table')
-page.wait_for_load_state('networkidle')
-
-# Check table content
-table = page.locator('.data-table')
-rows = table.locator('tbody tr')
-
-# Verify data loaded
-assert rows.count() > 0
-
-# Check specific data
-assert page.locator('text=John Doe').is_visible()
-```
-
-### Error Handling
-```python
-# Test error states
-page.goto('http://localhost:3000/invalid-page')
-page.wait_for_load_state('networkidle')
-
-# Check for error message
-error_message = page.locator('.error-message')
-assert error_message.is_visible()
-assert '404' in error_message.text_content()
-```
-
-## Debugging and Logging
-
-### Console Logs
-```python
-from playwright.sync_api import sync_playwright
-
-with sync_playwright() as p:
-    browser = p.chromium.launch(headless=False)  # Non-headless for debugging
-    page = browser.new_page()
-    
-    # Capture console messages
-    page.on('console', lambda msg: print(f'Browser console: {msg.text}'))
-    
-    # Capture JavaScript errors
-    page.on('pageerror', lambda error: print(f'Page error: {error}'))
-    
-    page.goto('http://localhost:5173')
-    browser.close()
-```
-
-### Screenshot Capture
-```python
-# Capture on failure
-try:
-    page.click('button')
-except Exception as e:
-    page.screenshot(path='/tmp/failure.png', full_page=True)
-    raise e
-
-# Full page screenshot
-page.screenshot(path='/tmp/full-page.png', full_page=True)
-
-# Element screenshot
-element = page.locator('.widget')
-element.screenshot(path='/tmp/widget.png')
-```
-
-## Best Practices
-
-### Critical Rules
-- **Always** wait for `networkidle` on dynamic apps before DOM inspection
-- Use `sync_playwright()` for synchronous scripts
-- Always close the browser when done
-- Use descriptive selectors (text, role, CSS, or IDs)
-- Add appropriate waits: `wait_for_selector()` or `wait_for_timeout()`
-
-### Performance Tips
-- Use headless mode for CI/automation: `headless=True`
-- Close unused pages to free memory
-- Use specific selectors over generic ones
-- Avoid unnecessary waits
-
-### Selector Strategy
-```python
-# Prefer these (most reliable):
-page.locator('text=Submit')           # Text content
-page.locator('role=button')           # ARIA role
-page.locator('#submit-form')          # ID
-page.locator('.button-primary')       # CSS class
-
-# Avoid these (less reliable):
-page.locator('button:nth-child(2)')   # Position-based
-page.locator('a[href*="login"]')      # Partial attribute match
-```
-
-## Reference Examples
-
-**Element Discovery:**
-```python
-# Find all interactive elements
-buttons = page.locator('button').all()
-for button in buttons:
-    print(f"Button: {button.text_content()}")
-```
-
-**Static HTML Testing:**
-```python
-# For local HTML files
-page.goto('file:///path/to/local/file.html')
-page.wait_for_load_state('networkidle')
-```
-
-## Usage Examples
-
-**Test React app:**
-`/webapp-testing "http://localhost:3000"`
-
-**Test with server management:**
-`/webapp-testing "npm run dev --port 3000"`
-
-**Debug UI issues:**
-`/webapp-testing "http://localhost:5173 --debug"`
-
-**Capture screenshots:**
-`/webapp-testing "http://localhost:3000 --screenshot"`
-
-Remember: Use bundled scripts as black boxes for complex workflows - they handle common patterns reliably.

package/packages/droid/commands/xlsx/recalc.py

@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-"""
-Excel Formula Recalculation Script
-Recalculates all formulas in an Excel file using LibreOffice
-"""
-
-import json
-import sys
-import subprocess
-import os
-import platform
-from pathlib import Path
-from openpyxl import load_workbook
-
-
-def setup_libreoffice_macro():
-    """Setup LibreOffice macro for recalculation if not already configured"""
-    if platform.system() == 'Darwin':
-        macro_dir = os.path.expanduser('~/Library/Application Support/LibreOffice/4/user/basic/Standard')
-    else:
-        macro_dir = os.path.expanduser('~/.config/libreoffice/4/user/basic/Standard')
-    
-    macro_file = os.path.join(macro_dir, 'Module1.xba')
-    
-    if os.path.exists(macro_file):
-        with open(macro_file, 'r') as f:
-            if 'RecalculateAndSave' in f.read():
-                return True
-    
-    if not os.path.exists(macro_dir):
-        subprocess.run(['soffice', '--headless', '--terminate_after_init'], 
-                      capture_output=True, timeout=10)
-        os.makedirs(macro_dir, exist_ok=True)
-    
-    macro_content = '''<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
-<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">
-    Sub RecalculateAndSave()
-      ThisComponent.calculateAll()
-      ThisComponent.store()
-      ThisComponent.close(True)
-    End Sub
-</script:module>'''
-    
-    try:
-        with open(macro_file, 'w') as f:
-            f.write(macro_content)
-        return True
-    except Exception:
-        return False
-
-
-def recalc(filename, timeout=30):
-    """
-    Recalculate formulas in Excel file and report any errors
-    
-    Args:
-        filename: Path to Excel file
-        timeout: Maximum time to wait for recalculation (seconds)
-    
-    Returns:
-        dict with error locations and counts
-    """
-    if not Path(filename).exists():
-        return {'error': f'File {filename} does not exist'}
-    
-    abs_path = str(Path(filename).absolute())
-    
-    if not setup_libreoffice_macro():
-        return {'error': 'Failed to setup LibreOffice macro'}
-    
-    cmd = [
-        'soffice', '--headless', '--norestore',
-        'vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application',
-        abs_path
-    ]
-    
-    # Handle timeout command differences between Linux and macOS
-    if platform.system() != 'Windows':
-        timeout_cmd = 'timeout' if platform.system() == 'Linux' else None
-        if platform.system() == 'Darwin':
-            # Check if gtimeout is available on macOS
-            try:
-                subprocess.run(['gtimeout', '--version'], capture_output=True, timeout=1, check=False)
-                timeout_cmd = 'gtimeout'
-            except (FileNotFoundError, subprocess.TimeoutExpired):
-                pass
-        
-        if timeout_cmd:
-            cmd = [timeout_cmd, str(timeout)] + cmd
-    
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    
-    if result.returncode != 0 and result.returncode != 124:  # 124 is timeout exit code
-        error_msg = result.stderr or 'Unknown error during recalculation'
-        if 'Module1' in error_msg or 'RecalculateAndSave' not in error_msg:
-            return {'error': 'LibreOffice macro not configured properly'}
-        else:
-            return {'error': error_msg}
-    
-    # Check for Excel errors in the recalculated file - scan ALL cells
-    try:
-        wb = load_workbook(filename, data_only=True)
-        
-        excel_errors = ['#VALUE!', '#DIV/0!', '#REF!', '#NAME?', '#NULL!', '#NUM!', '#N/A']
-        error_details = {err: [] for err in excel_errors}
-        total_errors = 0
-        
-        for sheet_name in wb.sheetnames:
-            ws = wb[sheet_name]
-            # Check ALL rows and columns - no limits
-            for row in ws.iter_rows():
-                for cell in row:
-                    if cell.value is not None and isinstance(cell.value, str):
-                        for err in excel_errors:
-                            if err in cell.value:
-                                location = f"{sheet_name}!{cell.coordinate}"
-                                error_details[err].append(location)
-                                total_errors += 1
-                                break
-        
-        wb.close()
-        
-        # Build result summary
-        result = {
-            'status': 'success' if total_errors == 0 else 'errors_found',
-            'total_errors': total_errors,
-            'error_summary': {}
-        }
-        
-        # Add non-empty error categories
-        for err_type, locations in error_details.items():
-            if locations:
-                result['error_summary'][err_type] = {
-                    'count': len(locations),
-                    'locations': locations[:20]  # Show up to 20 locations
-                }
-        
-        # Add formula count for context - also check ALL cells
-        wb_formulas = load_workbook(filename, data_only=False)
-        formula_count = 0
-        for sheet_name in wb_formulas.sheetnames:
-            ws = wb_formulas[sheet_name]
-            for row in ws.iter_rows():
-                for cell in row:
-                    if cell.value and isinstance(cell.value, str) and cell.value.startswith('='):
-                        formula_count += 1
-        wb_formulas.close()
-        
-        result['total_formulas'] = formula_count
-        
-        return result
-        
-    except Exception as e:
-        return {'error': str(e)}
-
-
-def main():
-    if len(sys.argv) < 2:
-        print("Usage: python recalc.py <excel_file> [timeout_seconds]")
-        print("\nRecalculates all formulas in an Excel file using LibreOffice")
-        print("\nReturns JSON with error details:")
-        print("  - status: 'success' or 'errors_found'")
-        print("  - total_errors: Total number of Excel errors found")
-        print("  - total_formulas: Number of formulas in the file")
-        print("  - error_summary: Breakdown by error type with locations")
-        print("    - #VALUE!, #DIV/0!, #REF!, #NAME?, #NULL!, #NUM!, #N/A")
-        sys.exit(1)
-    
-    filename = sys.argv[1]
-    timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 30
-    
-    result = recalc(filename, timeout)
-    print(json.dumps(result, indent=2))
-
-
-if __name__ == '__main__':
-    main()