@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.404.e9d4980.0

package/management-ui/README.md

@@ -1,203 +0,0 @@
-# Frigg Management UI
-
-A modern React-based management interface for Frigg development environment. Built with Vite, React, and Tailwind CSS, this application provides developers with a comprehensive dashboard to manage integrations, users, connections, and environment variables.
-
-## Features
-
-- **Dashboard**: Server control, metrics, and activity monitoring
-- **Integration Discovery**: Browse, install, and manage Frigg integrations
-- **Environment Management**: Configure environment variables and settings
-- **User Management**: Create and manage test users
-- **Connection Management**: Monitor and manage integration connections
-- **Real-time Updates**: WebSocket-based live updates
-- **Responsive Design**: Mobile-friendly interface
-- **Error Boundaries**: Robust error handling
-
-## Tech Stack
-
-- **React 18.3**: Modern React with hooks and functional components
-- **Vite**: Fast development and build tooling
-- **React Router**: Client-side routing
-- **Tailwind CSS**: Utility-first CSS framework
-- **Lucide React**: Modern icon library
-- **Socket.io**: Real-time communication
-- **Axios**: HTTP client
-- **@friggframework/ui**: Shared UI components
-
-## Getting Started
-
-### Prerequisites
-
-- Node.js 16+ and npm
-- Running Frigg backend server
-
-### Installation
-
-```bash
-# Install dependencies
-npm install
-
-# Start development server (frontend only)
-npm run dev
-
-# Start both frontend and backend
-npm run dev:server
-
-# Build for production
-npm run build
-```
-
-### Available Scripts
-
-- `npm run dev` - Start Vite development server
-- `npm run dev:server` - Start both frontend and backend concurrently
-- `npm run build` - Build for production
-- `npm run preview` - Preview production build
-- `npm run server` - Start backend server only
-- `npm run server:dev` - Start backend server with nodemon
-- `npm run lint` - Run ESLint
-- `npm run lint:fix` - Fix ESLint issues
-- `npm run typecheck` - Run TypeScript type checking
-
-## Project Structure
-
-```
-src/
-├── components/          # Reusable UI components
-│   ├── Button.jsx      # Custom button component
-│   ├── Card.jsx        # Card container components
-│   ├── ErrorBoundary.jsx
-│   ├── IntegrationCard.jsx
-│   ├── Layout.jsx      # Main layout component
-│   ├── LoadingSpinner.jsx
-│   ├── StatusBadge.jsx
-│   └── index.js        # Component exports
-├── hooks/              # React hooks
-│   ├── useFrigg.jsx    # Main Frigg state management
-│   └── useSocket.jsx   # WebSocket connection
-├── pages/              # Page components
-│   ├── Dashboard.jsx   # Main dashboard
-│   ├── Integrations.jsx
-│   ├── Environment.jsx
-│   ├── Users.jsx
-│   └── Connections.jsx
-├── services/           # API services
-│   └── api.js          # Axios configuration
-├── utils/              # Utility functions
-│   └── cn.js           # Class name utility
-├── App.jsx             # Root component
-├── main.jsx            # Application entry point
-└── index.css           # Global styles
-
-server/
-├── api/                # Backend API routes
-├── middleware/         # Express middleware
-├── utils/              # Server utilities
-├── websocket/          # WebSocket handlers
-└── index.js            # Server entry point
-```
-
-## Component Architecture
-
-### Layout Components
-- **Layout**: Main application layout with responsive sidebar
-- **ErrorBoundary**: Catches and displays errors gracefully
-
-### UI Components
-- **Button**: Customizable button with variants and sizes
-- **Card**: Container components for content sections
-- **StatusBadge**: Displays server status with color coding
-- **LoadingSpinner**: Loading indicators
-- **IntegrationCard**: Rich integration display component
-
-### State Management
-- **useFrigg**: Central state management for Frigg data
-- **useSocket**: WebSocket connection and real-time updates
-
-## API Integration
-
-The management UI communicates with the Frigg backend through:
-
-1. **REST API**: Standard CRUD operations
-2. **WebSocket**: Real-time updates and notifications
-
-### API Endpoints
-
-- `GET /api/frigg/status` - Server status
-- `POST /api/frigg/start` - Start Frigg server
-- `POST /api/frigg/stop` - Stop Frigg server
-- `GET /api/integrations` - List integrations
-- `POST /api/integrations/install` - Install integration
-- `GET /api/environment` - Environment variables
-- `PUT /api/environment` - Update environment variables
-- `GET /api/users` - List test users
-- `POST /api/users` - Create test user
-- `GET /api/connections` - List connections
-
-## Styling
-
-This project uses Tailwind CSS for styling with:
-
-- **Design System**: Consistent spacing, colors, and typography
-- **Responsive Design**: Mobile-first approach
-- **Component Variants**: Button and component style variants
-- **Dark Mode Ready**: CSS custom properties for theming
-
-### Custom Utilities
-
-- `cn()`: Utility for combining Tailwind classes with conditional logic
-
-## Error Handling
-
-- **Error Boundaries**: React error boundaries catch component errors
-- **API Error Handling**: Axios interceptors handle API errors
-- **Loading States**: Loading spinners and disabled states
-- **Validation**: Form validation and user feedback
-
-## Development
-
-### Code Style
-
-- **ESLint**: Linting with React and React Hooks rules
-- **Prettier**: Code formatting (recommended)
-- **TypeScript Ready**: Prepared for TypeScript migration
-
-### Best Practices
-
-- Functional components with hooks
-- Component composition over inheritance
-- Separation of concerns (UI, state, logic)
-- Error boundaries for robustness
-- Loading states for better UX
-- Responsive design principles
-
-## Building and Deployment
-
-```bash
-# Build for production
-npm run build
-
-# Preview production build
-npm run preview
-```
-
-The build output will be in the `dist/` directory and can be served by any static file server.
-
-## Environment Variables
-
-The application automatically detects the environment:
-
-- **Development**: API calls to `http://localhost:3001`
-- **Production**: API calls to the same origin
-
-## Contributing
-
-1. Follow the existing code style and patterns
-2. Add error handling for new features
-3. Include loading states for async operations
-4. Write tests for new components (when testing is set up)
-5. Update documentation for significant changes
-
-## License
-
-This project is part of the Frigg Framework and follows the same licensing terms.

package/management-ui/components.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "new-york",
-  "rsc": false,
-  "tsx": true,
-  "tailwind": {
-    "config": "tailwind.config.js",
-    "css": "src/index.css",
-    "baseColor": "neutral",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "iconLibrary": "lucide"
-}

package/management-ui/index.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Frigg Management UI</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.jsx"></script>
-  </body>
-</html>

package/management-ui/merge-conflict-cleaner.py

@@ -1,371 +0,0 @@
-#!/usr/bin/env python3
-"""
-Merge Conflict Cleaner Script
-
-This script automatically cleans up merge conflicts by:
-1. Removing duplicate imports
-2. Keeping the most complete version of duplicated code blocks
-3. Ensuring proper syntax after cleanup
-4. Preserving functionality while removing conflicts
-
-Focus on these key patterns:
-- Import dedupe and consolidation
-- Taking the most complete version of components
-- Preserving industrial design system elements
-- Keeping proper React patterns
-"""
-
-import os
-import re
-import sys
-from pathlib import Path
-from typing import List, Dict, Set, Tuple
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-class MergeConflictCleaner:
-    def __init__(self, base_path: str):
-        self.base_path = Path(base_path)
-        self.files_processed = 0
-        self.conflicts_resolved = 0
-        self.errors = []
-        
-    def find_conflict_files(self) -> List[Path]:
-        """Find all files with merge conflict markers"""
-        conflict_files = []
-        
-        for file_path in self.base_path.rglob('*.jsx'):
-            if self._has_conflicts(file_path):
-                conflict_files.append(file_path)
-        
-        for file_path in self.base_path.rglob('*.js'):
-            if self._has_conflicts(file_path):
-                conflict_files.append(file_path)
-                
-        for file_path in self.base_path.rglob('*.css'):
-            if self._has_conflicts(file_path):
-                conflict_files.append(file_path)
-        
-        return conflict_files
-    
-    def _has_conflicts(self, file_path: Path) -> bool:
-        """Check if file has merge conflict markers"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-                return any(marker in content for marker in ['<<<<<<<', '=======', '>>>>>>>'])
-        except Exception as e:
-            logger.error(f"Error reading {file_path}: {e}")
-            return False
-    
-    def clean_file(self, file_path: Path) -> bool:
-        """Clean merge conflicts in a single file"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            logger.info(f"Processing {file_path}")
-            
-            # Parse and resolve conflicts
-            cleaned_content = self._resolve_conflicts(content, file_path)
-            
-            # Write cleaned content back
-            with open(file_path, 'w', encoding='utf-8') as f:
-                f.write(cleaned_content)
-            
-            self.files_processed += 1
-            return True
-            
-        except Exception as e:
-            error_msg = f"Error processing {file_path}: {e}"
-            logger.error(error_msg)
-            self.errors.append(error_msg)
-            return False
-    
-    def _resolve_conflicts(self, content: str, file_path: Path) -> str:
-        """Resolve merge conflicts in content"""
-        lines = content.split('\n')
-        cleaned_lines = []
-        i = 0
-        
-        while i < len(lines):
-            line = lines[i]
-            
-            # Check for conflict start
-            if line.startswith('<<<<<<<'):
-                conflict_resolved = self._resolve_conflict_block(lines, i, file_path)
-                if conflict_resolved:
-                    resolved_lines, skip_count = conflict_resolved
-                    cleaned_lines.extend(resolved_lines)
-                    i += skip_count
-                    self.conflicts_resolved += 1
-                else:
-                    # If we can't resolve, keep the line as is
-                    cleaned_lines.append(line)
-                    i += 1
-            else:
-                cleaned_lines.append(line)
-                i += 1
-        
-        return '\n'.join(cleaned_lines)
-    
-    def _resolve_conflict_block(self, lines: List[str], start_idx: int, file_path: Path) -> Tuple[List[str], int]:
-        """Resolve a single conflict block"""
-        # Find the boundaries of the conflict
-        head_start = start_idx
-        separator_idx = -1
-        end_idx = -1
-        
-        for i in range(start_idx + 1, len(lines)):
-            if lines[i].startswith('======='):
-                separator_idx = i
-            elif lines[i].startswith('>>>>>>>'):
-                end_idx = i
-                break
-        
-        if separator_idx == -1 or end_idx == -1:
-            logger.warning(f"Malformed conflict block at line {start_idx + 1} in {file_path}")
-            return None
-        
-        # Extract the two versions
-        head_version = lines[head_start + 1:separator_idx]
-        incoming_version = lines[separator_idx + 1:end_idx]
-        
-        # Resolve based on file-specific logic
-        resolved_lines = self._choose_best_version(head_version, incoming_version, file_path)
-        
-        # Return resolved lines and number of lines to skip
-        return resolved_lines, end_idx - start_idx + 1
-    
-    def _choose_best_version(self, head_version: List[str], incoming_version: List[str], file_path: Path) -> List[str]:
-        """Choose the best version based on content analysis"""
-        
-        # Handle imports specially
-        if self._is_import_block(head_version) or self._is_import_block(incoming_version):
-            return self._merge_imports(head_version, incoming_version)
-        
-        # Handle export statements
-        if self._is_export_block(head_version) or self._is_export_block(incoming_version):
-            return self._merge_exports(head_version, incoming_version)
-        
-        # For Layout.jsx and similar component files, prefer the more complete version
-        if 'Layout.jsx' in str(file_path):
-            return self._resolve_layout_conflicts(head_version, incoming_version)
-        
-        # For Button.jsx, prefer the shadcn re-export version
-        if 'Button.jsx' in str(file_path):
-            return self._resolve_button_conflicts(head_version, incoming_version)
-        
-        # General heuristic: prefer the version with more content
-        if len(''.join(head_version).strip()) > len(''.join(incoming_version).strip()):
-            return head_version
-        else:
-            return incoming_version
-    
-    def _is_import_block(self, lines: List[str]) -> bool:
-        """Check if this is an import block"""
-        content = ''.join(lines).strip()
-        return content.startswith('import') or 'import' in content
-    
-    def _is_export_block(self, lines: List[str]) -> bool:
-        """Check if this is an export block"""
-        content = ''.join(lines).strip()
-        return content.startswith('export') or 'export' in content
-    
-    def _merge_imports(self, head_version: List[str], incoming_version: List[str]) -> List[str]:
-        """Merge and deduplicate imports"""
-        all_imports = set()
-        import_lines = []
-        
-        # Process both versions
-        for version in [head_version, incoming_version]:
-            for line in version:
-                line = line.strip()
-                if line and not line.startswith('//'):
-                    # Extract import statements
-                    if line.startswith('import'):
-                        if line not in all_imports:
-                            all_imports.add(line)
-                            import_lines.append(line)
-                    elif 'import' in line and '{' in line:
-                        # Handle multi-line imports
-                        if line not in all_imports:
-                            all_imports.add(line)
-                            import_lines.append(line)
-        
-        # Sort imports for consistency
-        import_lines.sort()
-        return import_lines
-    
-    def _merge_exports(self, head_version: List[str], incoming_version: List[str]) -> List[str]:
-        """Merge exports, preferring named exports"""
-        for version in [head_version, incoming_version]:
-            for line in version:
-                if 'export {' in line:
-                    return version
-        
-        # If no named exports, prefer the version with more content
-        if len(''.join(head_version).strip()) > len(''.join(incoming_version).strip()):
-            return head_version
-        else:
-            return incoming_version
-    
-    def _resolve_layout_conflicts(self, head_version: List[str], incoming_version: List[str]) -> List[str]:
-        """Resolve Layout.jsx specific conflicts"""
-        # Look for industrial design elements
-        head_content = ''.join(head_version)
-        incoming_content = ''.join(incoming_version)
-        
-        # Prefer version with industrial design elements
-        industrial_keywords = ['industrial', 'FriggLogo', 'ThemeToggle', 'RepositoryPicker']
-        
-        head_score = sum(1 for keyword in industrial_keywords if keyword in head_content)
-        incoming_score = sum(1 for keyword in industrial_keywords if keyword in incoming_content)
-        
-        if head_score > incoming_score:
-            return head_version
-        elif incoming_score > head_score:
-            return incoming_version
-        else:
-            # If equal, prefer the longer version
-            return head_version if len(head_content) > len(incoming_content) else incoming_version
-    
-    def _resolve_button_conflicts(self, head_version: List[str], incoming_version: List[str]) -> List[str]:
-        """Resolve Button.jsx conflicts - prefer shadcn re-export"""
-        head_content = ''.join(head_version)
-        incoming_content = ''.join(incoming_version)
-        
-        # Prefer the shadcn re-export version
-        if 'ui/button' in head_content:
-            return head_version
-        elif 'ui/button' in incoming_content:
-            return incoming_version
-        else:
-            # If neither has shadcn, prefer the more complete implementation
-            return head_version if len(head_content) > len(incoming_content) else incoming_version
-    
-    def verify_syntax(self, file_path: Path) -> bool:
-        """Basic syntax verification for JS/JSX files"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            # Basic checks
-            if file_path.suffix in ['.jsx', '.js']:
-                # Check for unbalanced braces
-                open_braces = content.count('{')
-                close_braces = content.count('}')
-                if open_braces != close_braces:
-                    logger.warning(f"Unbalanced braces in {file_path}")
-                    return False
-                
-                # Check for unbalanced parentheses
-                open_parens = content.count('(')
-                close_parens = content.count(')')
-                if open_parens != close_parens:
-                    logger.warning(f"Unbalanced parentheses in {file_path}")
-                    return False
-                
-                # Check for remaining conflict markers
-                if any(marker in content for marker in ['<<<<<<<', '=======', '>>>>>>>']):
-                    logger.warning(f"Remaining conflict markers in {file_path}")
-                    return False
-            
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error verifying syntax for {file_path}: {e}")
-            return False
-    
-    def run(self) -> Dict[str, any]:
-        """Run the merge conflict cleaner"""
-        logger.info(f"Starting merge conflict cleanup in {self.base_path}")
-        
-        # Find all files with conflicts
-        conflict_files = self.find_conflict_files()
-        
-        if not conflict_files:
-            logger.info("No merge conflicts found!")
-            return {
-                'files_processed': 0,
-                'conflicts_resolved': 0,
-                'errors': [],
-                'success': True
-            }
-        
-        logger.info(f"Found {len(conflict_files)} files with merge conflicts")
-        
-        # Process each file
-        successful_files = []
-        failed_files = []
-        
-        for file_path in conflict_files:
-            if self.clean_file(file_path):
-                if self.verify_syntax(file_path):
-                    successful_files.append(file_path)
-                    logger.info(f"✓ Successfully cleaned {file_path}")
-                else:
-                    failed_files.append(file_path)
-                    logger.error(f"✗ Syntax issues after cleaning {file_path}")
-            else:
-                failed_files.append(file_path)
-                logger.error(f"✗ Failed to clean {file_path}")
-        
-        # Summary
-        logger.info(f"Cleanup complete!")
-        logger.info(f"Files processed: {self.files_processed}")
-        logger.info(f"Conflicts resolved: {self.conflicts_resolved}")
-        logger.info(f"Successful: {len(successful_files)}")
-        logger.info(f"Failed: {len(failed_files)}")
-        
-        if failed_files:
-            logger.error("Failed files:")
-            for file_path in failed_files:
-                logger.error(f"  - {file_path}")
-        
-        if self.errors:
-            logger.error("Errors encountered:")
-            for error in self.errors:
-                logger.error(f"  - {error}")
-        
-        return {
-            'files_processed': self.files_processed,
-            'conflicts_resolved': self.conflicts_resolved,
-            'successful_files': successful_files,
-            'failed_files': failed_files,
-            'errors': self.errors,
-            'success': len(failed_files) == 0
-        }
-
-def main():
-    """Main entry point"""
-    if len(sys.argv) != 2:
-        print("Usage: python merge-conflict-cleaner.py <path-to-src-directory>")
-        sys.exit(1)
-    
-    src_path = sys.argv[1]
-    
-    if not os.path.exists(src_path):
-        print(f"Error: Path {src_path} does not exist")
-        sys.exit(1)
-    
-    cleaner = MergeConflictCleaner(src_path)
-    result = cleaner.run()
-    
-    if result['success']:
-        print(f"\n✓ All merge conflicts resolved successfully!")
-        print(f"   Files processed: {result['files_processed']}")
-        print(f"   Conflicts resolved: {result['conflicts_resolved']}")
-        sys.exit(0)
-    else:
-        print(f"\n✗ Some issues occurred during cleanup")
-        print(f"   Files processed: {result['files_processed']}")
-        print(f"   Conflicts resolved: {result['conflicts_resolved']}")
-        print(f"   Errors: {len(result['errors'])}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()