vibe_coder

Vibe Coder Agent

An AI-powered code generation tool that creates Python applications and HTML websites with minimal coding knowledge required. Leverages multiple LLM providers to assist in generating, managing, and executing projects through an interactive CLI interface.

Overview

The Vibe Coder Agent is designed for users who want to create projects with minimal or no coding experience. It uses artificial intelligence to automatically generate code, manage project environments, and handle dependency installation. The tool supports creating Streamlit applications, FastAPI services, and static HTML websites through conversational AI-driven requirements gathering.

Features

Installation

Prerequisites

Setup Instructions

  1. Clone the Repository 
    git clone https://github.com/your-username/vibe_coder.git
cd vibe_coder
  2. Install Dependencies 
    pip install -r requirements.txt
  3. Configure Environment Variables 
    cp .envcopy .env

    Edit the .env file with your API keys and configuration:

    nano .env  # or use your preferred editor

  4. Update LLM Client Configuration

    The openai_client.py file handles LLM provider connections. For most providers, you only need to update the .env file, but for custom setups, you may need to modify this file:

    # openai_client.py - Default configuration
from openai import OpenAI
import os
from dotenv import load_dotenv
   
load_dotenv()
   
def get_client():
    client = OpenAI(
        api_key=os.getenv("OPENAI_API_KEY"), 
        base_url=os.getenv("BASE_URL_OPENAI")
    )
    return client

    For different providers, update the environment variables in .env accordingly.

  5. Verify Installation

    Test your setup by running:

    python latest_coding_agent.py

    You should see the main menu with three options. If you encounter errors, check the troubleshooting section below.

Complete Setup Example (OpenAI)

Here’s a complete setup example using OpenAI:

# 1. Clone and navigate
git clone https://github.com/your-username/vibe_coder.git
cd vibe_coder

# 2. Install dependencies
pip install -r requirements.txt

# 3. Setup environment
cp .envcopy .env

# 4. Edit .env file (replace with your actual API key)
echo 'OPENAI_API_KEY=sk-proj-your-actual-openai-key-here' > .env
echo 'BASE_URL_OPENAI=https://api.openai.com/v1/' >> .env
echo 'MODEL_NAME=gpt-3.5-turbo' >> .env

# 5. Test the setup
python latest_coding_agent.py

For better dependency management, use a virtual environment:

# Create virtual environment
python -m venv vibe_coder_env

# Activate virtual environment
# On Windows:
vibe_coder_env\Scripts\activate
# On macOS/Linux:
source vibe_coder_env/bin/activate

# Install dependencies
pip install -r requirements.txt

# Continue with setup...

Configuration

Environment Variables

The application uses the following environment variables (defined in .env). These variables are based on the template provided in .envcopy:

# OpenAI Configuration
OPENAI_API_KEY=sk-proj-your-api-key-here
BASE_URL_OPENAI=https://api.openai.com/v1/

# DeepSeek Configuration  
BASE_URL_DEEPSEEK=https://api.deepseek.com/v1/

# Local LLM Configuration
LOCAL_URL=http://127.0.0.1:1234
LOCAL_API_KEY=your-local-api-key

# Model Configuration
MODEL_NAME=qwen2.5-coder-3b-instruct

Key Environment Variables:

Supported LLM Providers

OpenAI Configuration

DeepSeek Configuration

Local LLM Configuration

Ollama Configuration

Configuration Tips and Best Practices

Choosing the Right Provider

Model Selection Guidelines

Environment Variable Reference

Based on the .envcopy template, here are all available configuration options:

# Primary API Configuration
OPENAI_API_KEY=your-api-key-here          # Required for all providers
BASE_URL_OPENAI=provider-base-url         # Provider-specific base URL
MODEL_NAME=model-name                     # Model to use for generation

# Alternative URLs (from .envcopy)
BASE_URL_DEEPSEEK=https://api.deepseek.com/v1/
LOCAL_URL=http://127.0.0.1:1234          # Local LLM server URL
LOCAL_API_KEY=your-local-api-key         # Local server API key (if needed)

Provider Switching

To switch between providers, simply update these three variables in your .env file:

# Switch to DeepSeek
OPENAI_API_KEY=your-deepseek-key
BASE_URL_OPENAI=https://api.deepseek.com/v1/
MODEL_NAME=deepseek-coder

# Switch to Local LLM
OPENAI_API_KEY=local-placeholder
BASE_URL_OPENAI=http://127.0.0.1:1234/v1/
MODEL_NAME=qwen2.5-coder-3b-instruct

# Switch to Ollama
OPENAI_API_KEY=ollama-placeholder
BASE_URL_OPENAI=http://localhost:11434/v1/
MODEL_NAME=qwen2.5-coder:3b

Usage

Quick Start

Run the application:

python latest_coding_agent.py

Main Options

The application provides three main options:

  1. Create a new Python application - Generate Streamlit apps or FastAPI services
  2. Update an existing generated project - Modify and enhance previously created projects
  3. Create a static HTML website - Generate complete HTML/CSS/JavaScript websites

Example Workflow

================================================================================
Python Application Generator
================================================================================
Options:
1. Create a new Python application
2. Update an existing generated project
3. Create a static HTML website

Enter your choice (1, 2 or 3): 1
What would you like to build today? (Streamlit app or FastAPI service): streamlit app

Project Description: streamlit app

=== Gathering Requirements ===
Any Reference link eg doc: 

Question 1: What kind of application do you want to build with Streamlit?
Your response: data visualization dashboard

Question 2: What type of data will you be visualizing?
Your response: sales data with charts and graphs

✅ Requirements gathered (2 questions answered)

=== Generating and Running Code ===
Generated 3 files: app.py, requirements.txt, README.md
✅ Application started successfully!
🌐 You can access it at: http://localhost:8501
📂 Project location: /path/to/generated_projects/project_20250107_143022

Project Structure

vibe_coder/
├── latest_coding_agent.py      # Main application entry point
├── models.py                   # Pydantic models for structured AI responses
├── openai_client.py           # LLM client configuration
├── application_executor.py    # Application execution handler
├── project_analyzer.py        # Project analysis functionality
├── project_manager.py         # Project creation and management
├── file_manager.py            # File operations utilities
├── requirements_manager.py    # Dependency management
├── user_interaction.py        # User interface components
├── scraper_doc.py            # Web scraping for reference docs
├── utils.py                  # General utilities
├── requirements.txt          # Project dependencies
├── .envcopy                 # Environment variables template
├── .gitignore              # Git ignore rules
├── LICENSE                 # MIT License
├── README.md              # This file
├── run_command.txt        # Execution instructions
├── generated_projects/    # Directory for generated projects
└── old_version/          # Previous versions
    ├── v0.1_latest_coding_agent.py
    └── v0_old_coder.py

Key Files Description

Core Application Files

Project Management Components

User Interface and Utilities

Configuration and Documentation Files

Directory Structure

Generated Project Structure

When the application creates a new project, it generates the following structure:

generated_projects/project_20250107_143022/
├── app.py                    # Main application file (Streamlit/FastAPI)
├── requirements.txt          # Project-specific dependencies
├── README.md                # Project documentation
├── run_command.txt          # Command to run the application
├── static/                  # Static files (for web projects)
│   ├── css/
│   ├── js/
│   └── images/
└── templates/               # HTML templates (for FastAPI projects)
    └── index.html

Generated Project File Types

Usage Examples and Workflows

Feature 1: Creating New Python Applications

Example 1: Streamlit Data Visualization Dashboard

Complete User Interaction Flow:

$ python latest_coding_agent.py
================================================================================
Python Application Generator
================================================================================
Options:
1. Create a new Python application
2. Update an existing generated project
3. Create a static HTML website

Enter your choice (1, 2 or 3): 1
What would you like to build today? (Streamlit app or FastAPI service): streamlit dashboard

Project Description: streamlit dashboard

=== Gathering Requirements ===
Any Reference link eg doc: 

Question 1: What kind of data visualization dashboard do you want to create? What type of data will it display?
Your response: sales analytics dashboard with charts showing revenue trends, product performance, and customer demographics

Question 2: What specific chart types would you like to include? (e.g., line charts, bar charts, pie charts, scatter plots)
Your response: line charts for revenue trends, bar charts for product sales, pie charts for customer segments, and interactive filters

Question 3: Do you want the dashboard to use sample data or connect to a specific data source?
Your response: use sample sales data with realistic numbers

✅ Requirements gathered (3 questions answered)

=== Generating and Running Code ===
Attempt 1/3
Generated 4 files: app.py, requirements.txt, README.md, sample_data.py
Run command: streamlit run app.py

Installing dependencies...
✅ Dependencies installed successfully

Starting application...
✅ Application started successfully!
🌐 You can access it at: http://localhost:8501
📂 Project location: /path/to/generated_projects/project_20250107_143022
💻 To run it again: streamlit run app.py

=== Success! ===
Your application has been generated and is ready to use.
Location: /path/to/generated_projects/project_20250107_143022

Generated Files:

Example 2: FastAPI REST API Service

Complete User Interaction Flow:

$ python latest_coding_agent.py
================================================================================
Python Application Generator
================================================================================
Options:
1. Create a new Python application
2. Update an existing generated project
3. Create a static HTML website

Enter your choice (1, 2 or 3): 1
What would you like to build today? (Streamlit app or FastAPI service): fastapi todo api

Project Description: fastapi todo api

=== Gathering Requirements ===
Any Reference link eg doc: 

Question 1: What kind of API endpoints do you want for your todo application?
Your response: CRUD operations - create, read, update, delete todos, plus list all todos and mark as complete

Question 2: What data fields should each todo item have?
Your response: id, title, description, completed status, created date, due date, priority level

Question 3: Do you want authentication, database integration, or just in-memory storage for now?
Your response: in-memory storage with Pydantic models, no authentication needed for now

✅ Requirements gathered (3 questions answered)

=== Generating and Running Code ===
Attempt 1/3
Generated 5 files: main.py, models.py, requirements.txt, README.md, test_api.py
Run command: uvicorn main:app --reload

Installing dependencies...
✅ Dependencies installed successfully

Starting application...
✅ Application started successfully!
🌐 You can access it at: http://localhost:8000
📚 API Documentation: http://localhost:8000/docs
📂 Project location: /path/to/generated_projects/project_20250107_144530
💻 To run it again: uvicorn main:app --reload

=== Success! ===
Your application has been generated and is ready to use.
Location: /path/to/generated_projects/project_20250107_144530

Generated Files:

Feature 2: Updating Existing Projects

Complete User Interaction Flow:

$ python latest_coding_agent.py
================================================================================
Python Application Generator
================================================================================
Options:
1. Create a new Python application
2. Update an existing generated project
3. Create a static HTML website

Enter your choice (1, 2 or 3): 2

Found existing projects:
1. project_20250107_143022 - Streamlit project (Created: 2025-01-07 14:30:22)
   Main files: app.py, sample_data.py
2. project_20250107_144530 - FastAPI project (Created: 2025-01-07 14:45:30)
   Main files: main.py, models.py

Select a project number to update (or 0 to create new): 1

Selected project: /path/to/generated_projects/project_20250107_143022

=== Analyzing Project ===
Project Type: Streamlit
Main Features: Sales analytics dashboard with revenue trends, product performance charts, and customer demographics visualization
Current Files: app.py, sample_data.py, requirements.txt, README.md

What updates would you like to make to this project?
Your input: add user authentication and the ability to upload custom CSV data files

=== Gathering Update Requirements ===
Question 1: What type of authentication do you want to implement? (simple password, user accounts, OAuth, etc.)
Your response: simple password protection with a login form

Question 2: What CSV file format should users be able to upload? What columns are expected?
Your response: CSV files with columns: date, product, revenue, customer_segment, region

Question 3: Should the uploaded data replace the sample data or be added alongside it?
Your response: replace the sample data and allow users to switch between different uploaded datasets

✅ Update requirements gathered (3 questions answered)

=== Generating Updated Code ===
Generated 6 files: app.py, auth.py, data_handler.py, requirements.txt, README.md, sample_data.py
Updated/Added files:
- app.py (enhanced with authentication and file upload)
- auth.py (new - authentication functions)
- data_handler.py (new - CSV processing)
- requirements.txt (updated with new dependencies)

✅ Updated application started successfully!
🌐 You can access it at: http://localhost:8501
📂 Updated project location: /path/to/generated_projects/project_20250107_143022_updated_20250107_150015

=== Update Summary ===
Original project: /path/to/generated_projects/project_20250107_143022
Updated project: /path/to/generated_projects/project_20250107_143022_updated_20250107_150015
Updated/Added files:
- app.py
- auth.py
- data_handler.py
- requirements.txt

Feature 3: Creating HTML Websites

Complete User Interaction Flow:

$ python latest_coding_agent.py
================================================================================
Python Application Generator
================================================================================
Options:
1. Create a new Python application
2. Update an existing generated project
3. Create a static HTML website

Enter your choice (1, 2 or 3): 3
What kind of website would you like to build? portfolio website for a web developer

Website Description: portfolio website for a web developer

=== Gathering Requirements ===
Any Reference link eg doc: 

Question 1: What sections do you want on your portfolio website?
Your response: header with navigation, about me section, skills showcase, project portfolio with images, contact form, and footer

Question 2: What color scheme and design style do you prefer?
Your response: modern dark theme with blue accents, clean minimalist design, responsive layout

Question 3: Do you want any interactive features or animations?
Your response: smooth scrolling, hover effects on project cards, animated skill bars, and a working contact form

✅ Requirements gathered (3 questions answered)

=== Generating and Running Code ===
Attempt 1/3
Generated 8 files: index.html, styles.css, script.js, images/placeholder.jpg, README.md, contact.php, projects.json, favicon.ico
Run command: python -m http.server 8000

Starting application...
✅ Application started successfully!
🌐 You can access it at: http://localhost:8000
📂 Project location: /path/to/generated_projects/project_20250107_151245
💻 To run it again: python -m http.server 8000

=== Success! ===
Your application has been generated and is ready to use.
Location: /path/to/generated_projects/project_20250107_151245

Generated Files:

Sample Inputs and Expected Outputs

Input Examples for Different Project Types

Streamlit Applications:

FastAPI Services:

HTML Websites:

Expected Output Structure

For Streamlit Projects:

generated_projects/project_YYYYMMDD_HHMMSS/
├── app.py                 # Main Streamlit application
├── requirements.txt       # streamlit, pandas, plotly, etc.
├── README.md             # Usage instructions
├── run_command.txt       # streamlit run app.py
└── data/                 # Sample data files (if needed)
    └── sample_data.csv

For FastAPI Projects:

generated_projects/project_YYYYMMDD_HHMMSS/
├── main.py               # FastAPI application
├── models.py             # Pydantic models
├── requirements.txt      # fastapi, uvicorn, pydantic
├── README.md            # API documentation
├── run_command.txt      # uvicorn main:app --reload
└── tests/               # API tests (if generated)
    └── test_main.py

For HTML Projects:

generated_projects/project_YYYYMMDD_HHMMSS/
├── index.html           # Main HTML file
├── styles.css           # CSS styling
├── script.js            # JavaScript functionality
├── README.md           # Deployment instructions
├── run_command.txt     # python -m http.server 8000
├── images/             # Image assets
│   └── placeholder.jpg
└── assets/             # Additional assets
    ├── fonts/
    └── icons/

CLI Interface Navigation

Main Menu Options:

  1. Option 1: Create new Python application → Choose Streamlit or FastAPI → Requirements gathering → Code generation
  2. Option 2: Update existing project → Select from list → Describe changes → Enhanced code generation
  3. Option 3: Create HTML website → Describe website type → Requirements gathering → Static site generation

Requirements Gathering Process:

Code Generation and Execution:

Troubleshooting

Common Issues and Solutions

Dependency Installation Failures

Problem: pip install -r requirements.txt fails or packages don’t install correctly

Solutions:

API Key Configuration Problems

Problem: Authentication errors, invalid API key, or connection failures

Solutions:

Model Compatibility Issues

Problem: Model not found, unsupported features, or generation failures

Solutions:

Application Won’t Start

Problem: Generated applications fail to launch or crash immediately

Solutions:

Code Generation Issues

Problem: AI generates incomplete, incorrect, or non-functional code

Solutions:

File Permission and Path Issues

Problem: Cannot create files, permission denied, or path not found errors

Solutions:

Environment and System Issues

Problem: Import errors, module not found, or system-specific failures

Solutions:

Limitations

Known System Limitations

Dependency Installation Issues

Programming Knowledge Requirements

Model and AI Limitations

Application Complexity Constraints

Technical Infrastructure Requirements

Functional Limitations

Project Types and Features

Code Generation Scope

Update and Maintenance

Performance and Reliability Limitations

Generation Speed and Reliability

Resource Usage

Security and Privacy Considerations

Ideal For:

Not Recommended For:

Architecture Overview

User Input → Requirements Gathering → AI Code Generation → Project Creation → Dependency Installation → Application Execution

┌─────────────┐    ┌──────────────┐    ┌─────────────┐    ┌──────────────┐
│   CLI       │    │ Requirements │    │    LLM      │    │   Project    │
│ Interface   │───▶│  Gathering   │───▶│  Generation │───▶│  Creation    │
└─────────────┘    └──────────────┘    └─────────────┘    └──────────────┘
                           │                                       │
                           ▼                                       ▼
                   ┌──────────────┐                      ┌──────────────┐
                   │   Document   │                      │ Dependency   │
                   │   Scraping   │                      │ Management   │
                   └──────────────┘                      └──────────────┘
                                                                 │
                                                                 ▼
                                                        ┌──────────────┐
                                                        │ Application  │
                                                        │  Execution   │
                                                        └──────────────┘

Why Streamlit and FastAPI?

Streamlit and FastAPI provide the best combination for rapid application development:

Architecture Overview

System Architecture

The Vibe Coder Agent follows a modular architecture designed for extensibility and maintainability. The system is organized into distinct layers that handle different aspects of the code generation workflow.

┌─────────────────────────────────────────────────────────────────────────────┐
│                           VIBE CODER AGENT ARCHITECTURE                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐         │
│  │   CLI Interface │    │  User Interface │    │   Input Handler │         │
│  │                 │    │   Components    │    │                 │         │
│  │ • Main Menu     │◄──►│ • Prompts       │◄──►│ • Validation    │         │
│  │ • Option Select │    │ • Progress      │    │ • Sanitization  │         │
│  │ • Error Display │    │ • Formatting    │    │ • Type Checking │         │
│  └─────────────────┘    └─────────────────┘    └─────────────────┘         │
│           │                       │                       │                │
│           └───────────────────────┼───────────────────────┘                │
│                                   │                                        │
│  ┌─────────────────────────────────▼─────────────────────────────────┐     │
│  │                    CORE ORCHESTRATION LAYER                       │     │
│  │                                                                    │     │
│  │  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐ │     │
│  │  │ Requirements    │    │   AI Conversation│    │  Project        │ │     │
│  │  │ Gathering       │    │   Manager        │    │  Analyzer       │ │     │
│  │  │                 │    │                  │    │                 │ │     │
│  │  │ • Question Flow │◄──►│ • Context Mgmt   │◄──►│ • Type Detection│ │     │
│  │  │ • User Responses│    │ • Message History│    │ • File Analysis │ │     │
│  │  │ • Validation    │    │ • Model Selection│    │ • Update Logic  │ │     │
│  │  └─────────────────┘    └─────────────────┘    └─────────────────┘ │     │
│  └────────────────────────────────┬───────────────────────────────────┘     │
│                                   │                                        │
│  ┌─────────────────────────────────▼─────────────────────────────────┐     │
│  │                      LLM INTEGRATION LAYER                        │     │
│  │                                                                    │     │
│  │  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐ │     │
│  │  │   OpenAI        │    │   DeepSeek      │    │   Local LLM     │ │     │
│  │  │   Client        │    │   Client        │    │   Client        │ │     │
│  │  │                 │    │                 │    │                 │ │     │
│  │  │ • GPT Models    │    │ • Coder Models  │    │ • LM Studio     │ │     │
│  │  │ • API Handling  │    │ • API Handling  │    │ • Ollama        │ │     │
│  │  │ • Rate Limiting │    │ • Rate Limiting │    │ • Custom Servers│ │     │
│  │  └─────────────────┘    └─────────────────┘    └─────────────────┘ │     │
│  └────────────────────────────────┬───────────────────────────────────┘     │
│                                   │                                        │
│  ┌─────────────────────────────────▼─────────────────────────────────┐     │
│  │                    CODE GENERATION & PROCESSING                   │     │
│  │                                                                    │     │
│  │  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐ │     │
│  │  │  Pydantic       │    │   Code          │    │   File          │ │     │
│  │  │  Models         │    │   Generator     │    │   Manager       │ │     │
│  │  │                 │    │                 │    │                 │ │     │
│  │  │ • File Model    │◄──►│ • Template Mgmt │◄──►│ • File Creation │ │     │
│  │  │ • Event Models  │    │ • Code Validation│    │ • Directory Mgmt│ │     │
│  │  │ • Type Safety   │    │ • Multi-attempt │    │ • Path Handling │ │     │
│  │  └─────────────────┘    └─────────────────┘    └─────────────────┘ │     │
│  └────────────────────────────────┬───────────────────────────────────┘     │
│                                   │                                        │
│  ┌─────────────────────────────────▼─────────────────────────────────┐     │
│  │                    PROJECT MANAGEMENT LAYER                       │     │
│  │                                                                    │     │
│  │  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐ │     │
│  │  │   Project       │    │  Requirements   │    │  Application    │ │     │
│  │  │   Manager       │    │  Manager        │    │  Executor       │ │     │
│  │  │                 │    │                 │    │                 │ │     │
│  │  │ • Dir Creation  │◄──►│ • Dependency    │◄──►│ • App Startup   │ │     │
│  │  │ • Timestamping  │    │   Installation  │    │ • Process Mgmt  │ │     │
│  │  │ • Organization  │    │ • Pip Management│    │ • URL Detection │ │     │
│  │  └─────────────────┘    └─────────────────┘    └─────────────────┘ │     │
│  └─────────────────────────────────────────────────────────────────────     │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Workflow Diagram

The application follows a structured workflow from user input to application execution:

USER INPUT WORKFLOW
═══════════════════

┌─────────────┐
│   START     │
│ Application │
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Main Menu  │
│  Selection  │
│             │
│ 1. New App  │
│ 2. Update   │
│ 3. HTML     │
└──────┬──────┘
       │
       ▼
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Option 1  │    │   Option 2  │    │   Option 3  │
│  New Python │    │   Update    │    │    HTML     │
│ Application │    │  Existing   │    │   Website   │
└──────┬──────┘    └──────┬──────┘    └──────┬──────┘
       │                  │                  │
       ▼                  ▼                  ▼
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Choose    │    │   Select    │    │  Describe   │
│ Streamlit/  │    │  Project    │    │   Website   │
│   FastAPI   │    │ from List   │    │ Requirements│
└──────┬──────┘    └──────┬──────┘    └──────┬──────┘
       │                  │                  │
       └──────────────────┼──────────────────┘
                          │
                          ▼
                 ┌─────────────┐
                 │ REQUIREMENTS│
                 │  GATHERING  │
                 │   PHASE     │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Reference   │
                 │ Doc Input   │
                 │ (Optional)  │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Web Scraper │◄─── scraper_doc.py
                 │ Processing  │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ AI Question │◄─── models.py
                 │ Generation  │     (RequirementsGatheringEvent)
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ User Input  │◄─── user_interaction.py
                 │ Collection  │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Sufficient  │
                 │Requirements?│
                 └──────┬──────┘
                        │
                   ┌────▼────┐
                   │   NO    │
                   └────┬────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Continue    │
                 │ Questioning │
                 └──────┬──────┘
                        │
                        └─────────┐
                                  │
                   ┌────▼────┐    │
                   │   YES   │    │
                   └────┬────┘    │
                        │         │
                        ▼         │
                 ┌─────────────┐  │
                 │    CODE     │  │
                 │ GENERATION  │  │
                 │   PHASE     │  │
                 └──────┬──────┘  │
                        │         │
                        ▼         │
                 ┌─────────────┐  │
                 │ LLM Client  │◄─┼─── openai_client.py
                 │ Selection   │  │
                 └──────┬──────┘  │
                        │         │
                        ▼         │
                 ┌─────────────┐  │
                 │ AI Code     │◄─┼─── models.py
                 │ Generation  │  │     (CodeGenerationEvent)
                 └──────┬──────┘  │
                        │         │
                        ▼         │
                 ┌─────────────┐  │
                 │ Code        │  │
                 │ Validation  │  │
                 │ & Retry     │  │
                 └──────┬──────┘  │
                        │         │
                   ┌────▼────┐    │
                   │ Success?│    │
                   └────┬────┘    │
                        │         │
                   ┌────▼────┐    │
                   │   NO    │    │
                   │(Retry)  │    │
                   └────┬────┘    │
                        │         │
                        └─────────┘
                        
                   ┌────▼────┐
                   │   YES   │
                   └────┬────┘
                        │
                        ▼
                 ┌─────────────┐
                 │   PROJECT   │
                 │  CREATION   │
                 │    PHASE    │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Create      │◄─── project_manager.py
                 │ Project     │
                 │ Directory   │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Generate    │◄─── file_manager.py
                 │ Files       │
                 │ Structure   │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Write Code  │
                 │ Files to    │
                 │ Disk        │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ DEPENDENCY  │
                 │INSTALLATION │
                 │    PHASE    │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Install     │◄─── requirements_manager.py
                 │ Python      │
                 │ Packages    │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Handle      │
                 │ Install     │
                 │ Errors      │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │APPLICATION  │
                 │ EXECUTION   │
                 │   PHASE     │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Start       │◄─── application_executor.py
                 │ Application │
                 │ Process     │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Detect      │
                 │ Application │
                 │ URL & Port  │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ Display     │
                 │ Success     │
                 │ Message     │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │    END      │
                 │ Application │
                 │  Ready to   │
                 │    Use      │
                 └─────────────┘

Component Interaction Flow

The major components interact in a coordinated manner to deliver the complete functionality:

COMPONENT INTERACTION DIAGRAM
════════════════════════════

┌─────────────────────────────────────────────────────────────────────────────┐
│                            INTERACTION FLOW                                 │
└─────────────────────────────────────────────────────────────────────────────┘

latest_coding_agent.py (Main Controller)
    │
    ├─► user_interaction.py ──────► Collect user input and display prompts
    │
    ├─► scraper_doc.py ───────────► Process reference documentation URLs
    │
    ├─► openai_client.py ─────────► Initialize LLM client connection
    │
    ├─► models.py ────────────────► Structure AI requests and responses
    │                                │
    │                                ├─► RequirementsGatheringEvent
    │                                ├─► CodeGenerationEvent  
    │                                └─► ProjectAnalysisEvent
    │
    ├─► project_analyzer.py ──────► Analyze existing projects (Option 2)
    │
    ├─► project_manager.py ───────► Create and organize project directories
    │                                │
    │                                └─► file_manager.py ──► Create files
    │
    ├─► requirements_manager.py ───► Install Python dependencies
    │
    └─► application_executor.py ───► Start and manage applications

Data Flow:
User Input → Requirements Gathering → AI Processing → Code Generation → 
File Creation → Dependency Installation → Application Execution

Key Architectural Decisions

Modular Design

LLM Provider Abstraction

Project Management Strategy

Error Handling and Resilience

File System Organization

Data Models and Flow

The application uses Pydantic models to ensure type safety and structured communication:

DATA MODEL HIERARCHY
═══════════════════

File Model
├── name: str (filename)
└── content: str (file contents)

RequirementsGatheringEvent
├── all_details_gathered: bool
├── question: str
├── project_type: str
└── requirements: str

CodeGenerationEvent
├── generated_code: List[File]
└── run_command: str

ProjectAnalysisEvent
├── project_structure: str
├── project_type: str
├── main_features: str
└── suggested_updates: List[str]

This architecture ensures maintainability, extensibility, and reliable operation while providing a smooth user experience from initial input to running application.

Contributing

We welcome contributions! Please follow these steps:

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

Development Guidelines

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contact

For questions, issues, or contributions, please:

Demo Screenshots

FastAPI Application

FastAPI Demo

HTML Website

HTML Demo

This site is open source. Improve this page.