Téléchargement oneShotCodeGen - Téléchargement du code source oneShotCodeGen

oneShotCodeGen

Code Source AI

1.0.0

Télécharger

CLI du générateur d'applications

Un outil d'interface de ligne de commande pour générer des applications complètes avec React Admin Frontend et Supabase Backend.

Mises à jour

2025-01-27 (DocuSign + Web version):
- Ajout de l'intégration de DoCusign
- Ajout de la version Web hébergée sur Vercel avec du code ici: https://github.com/vivek100/webverion1
- Ajout de fonctions Vercel pour le backend pour les appels OpenAI et l'intégration DocuSign
2024-01-24 (intégration Docker & Nginx):
- Ajout d'options de déploiement Docker et Nginx pour les flux de création et de modification
- Prise en charge du déploiement conteneurisé avec proxy inverse Nginx en option
- Gestion automatique des ports et configuration des conteneurs
- Processus de déploiement simplifié avec une configuration de commande unique
2024-01-16 (Modifier le flux):
- Introduit des stratégies de mise à jour intelligentes pour modifier les applications existantes
- Ajout de la prise en charge du versioning pour les mises à jour des applications
- Prend en charge deux approches de mise à jour principales:
  - Régénération complète: reconstruire complet tout en préservant les fonctionnalités de base
  - Mise à jour du cas d'utilisation: modifications ciblées vers des composants spécifiques
- Système de sauvegarde intelligent qui crée des sauvegardes à horaire avant les modifications
- Suivi de version pour plusieurs itérations de la même application
2024-01-10 (Pipeline de génération d'IA optimisé):
- Génération d'IA restructurée de 2 appels à 4 appels spécialisés:
  1. Génération de cas d'utilisation: axée sur la logique métier et les flux de travail des utilisateurs
  2. Génération du modèle d'entité: schéma de base de données et relations
  3. Génération de données simulées: les données de test et les scénarios utilisateur
  4. Génération du modèle d'interface: composants et dispositions d'interface utilisateur
- Avantages:
  - Amélioration de la précision grâce à des invites spécialisées
  - Meilleure gestion des erreurs et validation entre les étapes
  - Utilisation réduite des jeton par appel
  - Capacité améliorée à maintenir le contexte
- L'approche originale de 2 appels est passée en mode héritage pour la compatibilité vers l'arrière
2024-12-20 (utilisation réduite des jetons de 70% et précision de 80%):
- Intégré aux contours pour générer la sortie structurée, il utilise une méthode où les logits sont attribués à faible ou zéro probabilité aux jetons qui ne font pas partie de la sortie, cela est fait juste avant que le jeton ne soit généré. Cela permet à l'outil d'obtenir une sortie de précision plus élevée avec des modèles plus petits
- La sortie structurée est ensuite utilisée pour générer le code frontend et backend qui, un peu comme des fichiers de configuration, cela aide à générer le code avec moins de jetons
  - La sortie DB est un JSON d'entités et leurs relations, cela est utilisé pour générer les requêtes SQL via le code Python et exécuter le SQL pour créer des tables et des vues sur Supabase
  - La sortie structurée frontale est structurée autour de React Admin et des composants, cela est utilisé pour générer le code frontal à l'aide de modèles Jinja2
  - Le backend est simulé à l'aide du client Supabase JS via Dataproviders
- Ensemble, cela permet à l'outil de générer le frontend et le code backend avec moins de jetons, une précision plus élevée et avec un modèle plus petit comme GPT-4O-MINI

Caractéristiques

Génére des applications réagantes complètes avec des composants de matériau-UI
S'intègre à Supabase pour les services backend
Comprend l'authentification et l'autorisation
Génère des opérations CRUD pour les entités
Prend en charge les modèles de domaine personnalisés
Comprend des composants prédéfinis (tables, formulaires, graphiques, etc.)

Condition préalable

Python 3,8 ou plus
Node.js et NPM
Compte Supabase
Docker (facultatif, pour le déploiement conteneurisé)
Nginx (facultatif, pour proxy inversé)

Configuration Docker & Nginx (facultatif)

Installer Docker:

 # For Ubuntu
sudo apt-get update
sudo apt-get install docker.io
sudo systemctl start docker
sudo systemctl enable docker

# For macOS/Windows
Download and install Docker Desktop from https://www.docker.com/products/docker-desktop

Image de base de construction:

 # Navigate to the project root directory
cd oneShotCodeGen

# Build the base image
docker build -t base-image -f base.Dockerfile .

# Verify the image was created
docker images | grep base-image

Installer nginx:

 # For Ubuntu
sudo apt-get install nginx
sudo systemctl start nginx
sudo systemctl enable nginx

# For macOS
brew install nginx

# For Windows
Download and install Nginx from http://nginx.org/en/download.html

Configurer les autorisations utilisateur Nginx (Linux / MacOS):

 # Add your user to nginx group
sudo usermod -aG nginx $USER
# Ensure nginx config directory is writable
sudo chown -R $USER : $USER /etc/nginx/conf.d

Remarque: L'image de base ne doit être construite qu'une seule fois, sauf si vous apportez des modifications au dockerfile. Cette image de base contient toutes les dépendances et configurations nécessaires qui seront utilisées comme base pour toutes les applications générées.

Installation

Cloner le référentiel
Installer le package: pip install -r requirements.txt

Usage

Configurez vos variables d'environnement dans .env :

OPENAI_API_KEY=your_openai_api_key
SUPABASE_PROJECT_URL=your_supabase_url
SUPABASE_ANON_KEY=your_supabase_anon_key
SUPABASE_DB_PASSWORD=your_db_password

Assurez-vous que les autorisations suivantes sont définies pour que le frontend exécute les requêtes agrégées:

ALTER ROLE authenticator SET pgrst . db_aggregates_enabled = ' true ' ;
NOTIFY pgrst, ' reload config ' ;

Générer une application avec Docker:

a. Latest version
# Just code generation
python -m src.cli create " Create an expense tracker app "

# With Docker only
python -m src.cli create " Create an expense tracker app " --docker

# With Docker and Nginx
python -m src.cli create " Create an expense tracker app " --docker --nginx

né Utilisation du mode héritage (approche 2-Call):

python -m src.cli create " Create an expense tracker app " --use-legacy

c. Ajout du répertoire de sortie personnalisé:

python -m src.cli create " Create an expense tracker app " --output-dir " path/to/
outputfolder "

Modifiez une application existante avec Docker:

 # Just code generation
python -m src.cli edit < project_dir > --description " Add a dashboard for expense 
analytics "
# With Docker only
python -m src.cli edit < project_dir > --description " Add a dashboard " --docker

# With Docker and Nginx
python -m src.cli edit < project_dir > --description " Add a dashboard " --docker --nginx

Exécution de l'application:

un. Développement local (par défaut):

 cd output/{output_folder_name}/frontend
npm install
npm run dev

né Déploiement de Docker:

L'application sera disponible sur http://localhost:<port>
Le port est automatiquement attribué et affiché après le déploiement

c. Docker avec nginx:

L'application sera disponible sur http://localhost/{app_name}
Nginx gère le routage et l'équilibrage de la charge

Options de déploiement

Développement local
- Server de développement basé sur NPM direct
- Meilleur pour le développement et les tests
- RELORAGE À HOT Activé
Déploiement de Docker
- Application conteneurisée
- Environnement isolé
- Gestion automatique des ports
- Convient à la production
Docker avec nginx
- Configuration proxy inverse
- Routage basé sur le chemin
- Capacité d'équilibrage de charge
- Configuration de production améliorée

Contrôle de version

Les applications incluent désormais le suivi de la version
Format de version: v0, v1, v2, etc.
Incréments de numéro de version basés sur l'historique de sauvegarde
Aide à suivre plusieurs itérations de la même application

Structure du projet

app-generator-cli/
├── src/ # Source code for the CLI
├── output/ # Generated applications
│ └── [timestamp]/ # Timestamp-based output directory
│   ├── frontend/ # React frontend application
│   ├── use_cases.json # Use case definitions
│   ├── entities.json # Entity model
│   ├── mock_users.json # Mock user data
│   ├── mock_data.json # Generated test data
│   ├── domain_model.json # Combined application model
│   ├── interface_model.json # UI/UX specifications
│   ├── sql/ # Generated SQL migrations
│   ├── src/ # Generated application source
│   └── generation.log # Generation process log
└── .env # Environment variables

Modifier le flux

Le système de flux d'édition vous permet de modifier les applications existantes tout en maintenant la cohérence et la sécurité. Voici comment l'utiliser:

Mettre à jour une application existante:

python -m src.cli update " Add a dashboard for expense analytics "

Le système sera:
- Analyser votre demande de modification
- Choisissez une stratégie de mise à jour appropriée
- Créez une sauvegarde de votre application actuelle
- Appliquer les modifications tout en maintenant la cohérence des données

Mettre à jour les stratégies

Régénération complète
- Utilisé pour les changements architecturaux majeurs
- Préserve les fonctionnalités existantes lors de la reconstruction de l'application
- Maintient la cohérence des données avec les modèles existants
Mise à jour partielle
- Pour des modifications ciblées à des composants spécifiques
- Mise à jour uniquement les parties affectées de l'application
- Prend en charge les mises à jour modulaires de:
  - Les cas d'utilisation et les workflows
  - Modèles et relations entités
  - Mock Data and Test Users
  - Composants d'interface

Système de sauvegarde

Sauvegardes automatiques créées avant toute modification
Répertoires de sauvegarde horodomagistes: backups/backup_YYYYMMDD_HHMMSS/
Rollback facile si nécessaire

Structure d'application générée

L'outil génère une application React avec la structure suivante:

frontend/
├── src/
│ ├── components/ # Reusable UI components
│ │ ├── Button.jsx
│ │ ├── Card.jsx
│ │ ├── Chart.jsx
│ │ ├── Form.jsx
│ │ ├── Modal.jsx
│ │ └── Table.jsx
│ ├── pages/ # Application pages
│ ├── providers/ # Data and auth providers
│ └── App.js # Main application component
└── package.json # Project dependencies