C'

.env

@@ -1,2 +1,3 @@
-DATABASE_URL=sqlite+aiosqlite:///./app.db
-ENVIRONMENT=production 
+AWS_ACCESS_KEY_ID="AKIAVRUVQMZRVWTZE4N4"
+AWS_SECRET_ACCESS_KEY="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"
+AWS_DEFAULT_REGION="eu-west-3"

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1 +0,0 @@
-sql_app.db

alembic/env.py

@@ -1,66 +0,0 @@
-import asyncio
-from logging.config import fileConfig
-
-from sqlalchemy import pool
-from sqlalchemy.engine import Connection
-from sqlalchemy.ext.asyncio import async_engine_from_config
-
-from alembic import context
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-from app.db.models import Base
-target_metadata = Base.metadata
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode."""
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-def do_run_migrations(connection: Connection) -> None:
-    context.configure(connection=connection, target_metadata=target_metadata)
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-async def run_async_migrations() -> None:
-    """In this scenario we need to create an Engine
-    and associate a connection with the context."""
-
-    connectable = async_engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-
-    await connectable.dispose()
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode."""
-
-    asyncio.run(run_async_migrations())
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online() 

alembic/script.py.mako

@@ -1,26 +0,0 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision: str = ${repr(up_revision)}
-down_revision: Union[str, None] = ${repr(down_revision)}
-branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
-depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    ${downgrades if downgrades else "pass"} 

app.log

@@ -0,0 +1,22 @@
+2025-02-28 18:27:16,754 - INFO - Chat request received with 1 messages
+2025-02-28 18:27:16,755 - INFO - Formatted prompt: give me saas app
+
+2025-02-28 18:27:29,908 - INFO - Generated response: i want to download saas app
+2025-02-28 18:28:08,376 - INFO - Feature generation request received with requirements: gerneate me 10 feature to use in saas
+2025-02-28 18:28:08,377 - INFO - Generated prompt: Generate 5 features based on the following requirements. Format each feature as a JSON object with 'feature' and 'short_description' fields.
+
+Requirements: gerneate me 10 feature to use in saas
+2025-02-28 18:29:29,392 - INFO - Model response: i would like 10 feature to use in saas
+2025-02-28 18:29:29,392 - INFO - Returning features: [Feature(feature='Feature 1', short_description='Description 1'), Feature(feature='Feature 2', short_description='Description 2')]
+2025-02-28 18:31:00,786 - INFO - Feature generation request received with requirements: gerneate me 10 feature to use in saas
+2025-02-28 18:31:00,787 - INFO - Generated prompt: Generate 5 detailed SaaS features based on the following requirements. Each feature should be practical and implementation-ready. Format your response as a list of JSON objects, each with 'feature' and 'short_description' fields.
+
+Example format:
+{
+  'feature': 'User Authentication',
+  'short_description': 'Secure login system with OAuth2 and MFA support'
+}
+
+Requirements: gerneate me 10 feature to use in saas
+
+Provide 5 features in the exact JSON format shown above.

app/.env

@@ -0,0 +1,3 @@
+AWS_ACCESS_KEY_ID="AKIAVRUVQMZRVWTZE4N4"
+AWS_SECRET_ACCESS_KEY="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"
+AWS_DEFAULT_REGION="eu-west-3"

app/__init__.py

@@ -0,0 +1 @@
+#uvicorn app.main:app --host 0.0.0.0 --port 8000   

app/controllers/f5_model.py

@@ -0,0 +1,86 @@
+from typing import List, Optional
+from pydantic import BaseModel
+import torch
+import logging
+from transformers import pipeline
+
+class F5ModelHandler:
+    def __init__(self):
+        logging.info("Initializing F5ModelHandler...")
+        try:
+            logging.info("Loading model 'google/flan-t5-small'...")
+            self.model_name = "google/flan-t5-small"
+            # Use pipeline for simpler model loading
+            self.generator = pipeline(
+                "text2text-generation",
+                model=self.model_name,
+                device="cuda" if torch.cuda.is_available() else "cpu",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+            )
+            logging.info(f"Model loaded successfully on {self.generator.device}")
+        except Exception as e:
+            logging.error(f"Error loading model: {str(e)}")
+            raise
+        
+    async def generate_response(self, prompt: str, max_length: int = 2048) -> str:
+        try:
+            logging.info(f"Generating response for prompt: {prompt[:100]}...")
+            
+            # Generate with more focused parameters
+            response = self.generator(
+                prompt,
+                max_length=max_length,
+                num_beams=5,
+                temperature=0.7,
+                top_p=0.95,
+                top_k=50,
+                repetition_penalty=1.2,
+                length_penalty=1.0,
+                do_sample=True,
+                num_return_sequences=1
+            )[0]['generated_text']
+            
+            # Clean up the response
+            response = response.strip()
+            
+            # Ensure minimum content length
+            if len(response) < 100:
+                logging.warning("Response too short, regenerating...")
+                return await self.generate_response(prompt, max_length)
+            
+            logging.info(f"Generated response successfully: {response[:100]}...")
+            return response
+            
+        except Exception as e:
+            logging.error(f"Error generating response: {str(e)}")
+            raise
+
+    async def stream_response(self, prompt: str, max_length: int = 1000):
+        try:
+            response = self.generator(
+                prompt,
+                max_length=max_length,
+                num_beams=4,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True,
+                return_full_text=False
+            )[0]['generated_text']
+            
+            # Simulate streaming by yielding chunks of the response
+            chunk_size = 20
+            for i in range(0, len(response), chunk_size):
+                chunk = response[i:i + chunk_size]
+                yield chunk
+
+        except Exception as e:
+            logging.error(f"Error in stream_response: {str(e)}")
+            raise
+
+# Initialize the model handler
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+f5_model = F5ModelHandler()

app/controllers/plan_chat_controller.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse, PlainTextResponse
+from pydantic import BaseModel, Field
+from typing import List, Literal
+from app.helpers.plan_chat import ask_plan_question
+from app.helpers.token_auth import get_token
+from app.helpers.get_current_uesr import get_user_from_token
+from app.models.project import Project
+from app.helpers.vectorization import search_similar
+
+router = APIRouter()
+
+class HistoryItem(BaseModel):
+    message: str
+    from_: Literal["user", "ai"]
+
+class PlanChatPayload(BaseModel):
+    query: str
+    history: List[HistoryItem]
+    project_id: str
+
+@router.post("/plan-chat")
+async def plan_chat(data: PlanChatPayload, token: str = Depends(get_token)):
+    """
+    Handle chat messages for plan generation with context from scraped content
+    """
+    try:
+        # Validate user
+        user = await get_user_from_token(token=token)
+        if not user:
+            raise HTTPException(status_code=401, detail="Invalid token")
+
+        # Get project context
+        project = await Project.get_or_none(id=data.project_id)
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+        # Get relevant context from vectorstore
+        context = await search_similar(data.query)
+
+        # Prepare system prompt
+        system_prompt = (
+            "You are a solution architect assistant specialized in cloud architecture. "
+            "Use the following context to help answer questions about the project plan. "
+            "Focus on providing specific, actionable advice based on the project requirements "
+            "and scraped documentation.\n\n"
+            f"Project Context: {context}\n"
+            f"Project Requirements: {project.requirements}\n"
+            f"Project Features: {project.features}\n"
+            f"Solution Stack: {project.solution_stack}\n"
+        )
+
+        async def response_stream():
+            async for chunk in ask_plan_question(
+                question=data.query,
+                history=data.history,
+                project_context=system_prompt
+            ):
+                yield chunk
+
+        return StreamingResponse(response_stream(), media_type="text/plain")
+
+    except Exception as e:
+        return PlainTextResponse(str(e), status_code=500)

app/controllers/scraper_controller.py

@@ -0,0 +1,45 @@
+from fastapi import APIRouter, Request, HTTPException
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel, HttpUrl
+from app.services.scraper_service import ScraperService
+from app.services.flan_t5_service import FlanT5Service
+from typing import Optional
+
+router = APIRouter()
+templates = Jinja2Templates(directory="app/templates")
+
+scraper_service = ScraperService()
+flan_t5_service = FlanT5Service()
+
+class ScrapeRequest(BaseModel):
+    url: HttpUrl
+    prompt_template: Optional[str] = "Summarize the following text: {text}"
+
+@router.post("/api/scrape")
+async def scrape_url(data: ScrapeRequest):
+    try:
+        # Scrape and process the URL
+        text, chunks = await scraper_service.scrape_and_process(str(data.url))
+        
+        # Process each chunk with Flan-T5
+        results = []
+        for chunk in chunks:
+            prompt = data.prompt_template.format(text=chunk.page_content)
+            response = await flan_t5_service.generate_response(prompt)
+            results.append(response)
+        
+        # Combine results
+        final_result = " ".join(results)
+        
+        return {
+            "success": True,
+            "result": final_result,
+            "url": str(data.url)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/history")
+async def show_history(request: Request):
+    # You can add history functionality later if needed
+    return templates.TemplateResponse("history.html", {"request": request})

app/helpers/chat.py

@@ -0,0 +1,38 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from helpers.generate_embbedings import vector_store
+from helpers.f5_model import f5_model
+
+def make_prompt(history, prompt, context=None):
+    formatted_history = ""
+
+    if context:
+        formatted_history += f"[CONTEXT] {context} [/CONTEXT]\n"
+
+    for history_item in history:
+        if history_item.from_ == 'user':
+            formatted_history += f"[INST] {history_item.message} [/INST]\n"
+        else:
+            formatted_history += f"{history_item.message}\n"
+
+    formatted_history += f"[INST] {prompt} [/INST]\n"
+
+    return formatted_history
+
+async def ask_question(question: str, history: list = [], project_id=None):
+    """
+    Generate a response using F5 model based on history and project-specific context.
+    """
+    try:
+        context = ""
+        if project_id is not None:
+            context = vector_store.similarity_search(
+                query=question, k=4, filter={"project_id": project_id}
+            )
+        
+        prompt = make_prompt(history, question, context)
+
+        async for chunk in f5_model.stream_response(prompt):
+            yield chunk
+    except Exception as e:
+        raise RuntimeError(f"Error generating response: {str(e)}")

app/helpers/generate_features.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel
+from models.features import Feature as FeatureModel
+from typing import List
+from helpers.f5_model import f5_model
+
+class Feature(BaseModel):
+    feature: str
+    short_description: str
+
+class Features(BaseModel):
+    features: List[Feature]
+
+async def generate_features(requirements: str):
+    query = (
+        "See the user requirements and propose him the features (it should be 20 features). Feature names should be short. "
+        "The user will then choose one or more needed features. \n"
+        "User Requirements:\n"
+        f"{requirements}"
+    )
+    
+    response = await f5_model.generate_response(query)
+    # Parse the response into Features structure
+    # You might need to add additional parsing logic here
+    features_dict = parse_features_response(response)
+    return Features(**features_dict)
+
+def parse_features_response(response: str) -> dict:
+    # Add parsing logic here to convert F5 model output to Features format
+    # This is a placeholder implementation
+    features_list = []
+    # Parse the response and create Feature objects
+    return {"features": features_list}

app/helpers/generate_plan.py

@@ -0,0 +1,256 @@
+
+
+class ScopeObjective(BaseModel):
+    scope: str = Field(description="Define the core functionalities of the system")
+    objectives: List[str] = Field(description="List at least three objectives focusing on user needs and system capabilities")
+
+class ArchitectureObjectives(BaseModel):
+    component: str = Field(description="architecture component for the project")
+    objectives: str = Field(description="project objectives, each associated with a key architecture component")
+
+class ComponenetDesign(BaseModel):
+    component: str = Field(description="core component for the project")
+    purpose: str = Field(description="purpose of the core component")
+    interactions: str = Field(description="interactions between the core components")
+    specifications: str = Field(description="specifications for the core components")
+
+class TeamRolesSkillsRequirements(BaseModel):
+    role: str = Field(description="role for the team member")
+    skills: str = Field(description="skills required for this particular job")
+
+class CostEstimatesOptimization(BaseModel):
+    estimated_costs: str = Field(description="estimated cost for the project")
+    optimization_strategies: List[str] = Field(description="Optimized Strategy for the project, it will always be a list of strings")
+
+class Tasks(BaseModel):
+    name: str = Field(description="Name of the task")
+    subtasks: List[str] = Field(description="sub tasks relevant for the task")
+
+class Phases(BaseModel):
+    name: str = Field(description="name of the phase")
+    tasks: List[Tasks] = Field(description="Tasks for this phase")
+
+class ProjectTasksMileStones(BaseModel):
+    phases: List[Phases] = Field(description="Phases for the project")
+
+class PlanOutput(BaseModel):
+    executive_summary: str = Field(description="concise overview of the project objectives, highlighting key features, targeted users, and platform (e.g., AWS)")
+    scope_objectives: ScopeObjective = Field(description="Scope and Objective for the project")
+    architecture_overview: str = Field(description="Overview of the system architecture, detailing the primary components and how they interact")
+    architecture_objectives: List[ArchitectureObjectives] = Field(description="List at least three objectives, each associated with a key architecture component, such as compute, storage, or network.")
+    component_design: List[ComponenetDesign] = Field(description="Detail at least two core components, including their purpose, interactions, and specifications")
+    security_and_compliance: List[str] = Field(description="List at least three security and compliance measures as strings, it should always be list of strings")
+    deployment_testing_monitoring: List[str] = Field(description="List of different points of deployment, testing, and monitoring, describing CI/CD, testing types, and monitoring approaches. it should always be list of strings")
+    team_roles_skills_requirements: List[TeamRolesSkillsRequirements] = Field(description="Define the roles needed for the project and their respective skill sets")
+    cost_estimates_optimization: CostEstimatesOptimization = Field(description="Cost Estimates for the project and strategies to optimize resources: don't include the cost just the explanation for the cost")
+    project_tasks_milestones: ProjectTasksMileStones = Field(description="Major project tasks and milestones, structured by phases")
+
+async def generate_rough_plan(data, token):
+    prompt = (
+    f"Requirements: {data.requirements}\n"
+    f"Backend: {data.backend}\n"
+    f"Frontend: {data.frontend}\n"
+    f"Database: {data.database}\n"
+    f"Features: {data.features} \n"
+    f"Additional Features: {data.additional_feature} \n"
+    + "\n".join([
+        f"{qa.question}\n{qa.answer}"
+        for qa in data.question_answers
+    ])
+    + "\n\n"
+    "Based on the provided details, please generate a comprehensive project description with the following sections:\n"
+    "1. Executive Summary\n"
+    f"   Provide a concise overview of the project objectives, highlighting key features, targeted users, and platform (e.g., AWS) it should be atleast 4, 5 lines long also add 3 key outcomes. it should also focus of platform {data.platform}\n"
+    "2. Project Scope and Objectives\n"
+    f"   - Scope: Define the core functionalities of the system 3 scopes and 3 objectives. focusing of platform {data.platform}\n"
+    f"   - Objectives: List at least three objectives focusing on user needs and system capabilities focusing on platofrm {data.platform}.\n"
+    "3. Architecture Overview\n"
+    f"   - Provide an overview of the system architecture, detailing the primary components and how they interact.focusing mostly on {data.platform}\n"
+    "4. Architecture Objectives\n"
+    f"   - List at least three objectives, each associated with a key architecture component, such as frontend, backend, database, media storage, Authentication,  compute, storage, or network. include all 6, 7 points focusing mostly on platofrm {data.platform}\n"
+    "5. Component Design\n"
+    f"   - Detail at least two core components, including their purpose, interactions, and specifications. focus mostly on {data.platform}\n"
+    "6. Security and Compliance\n"
+    f"   - List at least three security and compliance measures, such as data encryption, authentication, and compliance standards. focus mostly on {data.platform}\n"
+    "7. Deployment, Testing, and Monitoring\n"
+    f"   - Include at least three aspects of deployment, testing, and monitoring, describing CI/CD, testing types, and monitoring approaches. focus mostly on {data.platform}\n"
+    "8. Team Roles and Skills Requirements\n"
+    f"   - Define the roles needed for the project and their respective skill sets.focus mostly on {data.platform}\n"
+    "9. Cost Estimates and Optimization\n"
+    f"   - Provide explanation for the cost (not including any digits or estimate just the explanation) and strategies to optimize resources {data.platform} (e.g., autoscaling, storage management).\n"
+    "10. Project Tasks and Milestones\n"
+    f"   - Outline major project tasks and milestones, structured by phases (e.g., architecture design, development, testing, deployment). {data.platform}\n\n"
+    "11. Architecture Design Phase \n"
+    "   - Define Architecture Design Phase for the project with main task and subtasks (Include exactly 3 tasks and 3 subtasks for each tasks) \n"
+    "12. Development Phase \n"
+    "    - Define Development Phase for the project with main task that can be represented on the kanman, (Include exactly 4 tasks and 3 subtasks for each tasks) \n"
+    "13. Testing Phase \n"
+    "     - Define Testing Phase for the project with main task that can be represented on the kanman, (Include exactly 2 tasks and 3 subtasks for each tasks)"
+    "14. Deployment Phase \n"
+    "      - Define Deployment Phase for the project with main task that can be represented with the kanman (Include exactly 3 tasks and 2 subtasks for each tasks)"
+    "Output format:\n"
+    "The output should be a valid JSON structure with each section represented as a JSON object. For example:\n\n"
+
+    f"Note: the description or content for each section should foces on platform and include data sepcific to that platoform{data.platform}"
+    f"{json_output_format}"
+    )
+
+    
+    output = ""
+    user = await get_user_from_token(token=token)
+    async for chunk in ask_question(question= prompt, history=[], use_context=False):
+        output += chunk
+    project_title = data.project_title
+    json_response = parse_and_return_json(output)
+    if (data.project_title == "" or data.project_title == None):
+        generated_project_title = await generate_project_title(requirements=data.requirements)
+        project_title = generated_project_title.split(":")[0].strip('"')
+    try:
+        print(f"Json Response before generate_plan_html: {json_response}")
+        plan_html = generate_plan_html(data=json.loads(json_response))
+        print(f"Json Response before generate_plan_html:")
+        project_id = await save_final_plan(project_title=project_title,
+                                user=user,
+                                data=data,
+                                json_response=json_response,
+                                plan_html=plan_html)
+
+        print(f"Project ID: {project_id}")
+        return {
+            "project_title": project_title,
+            "project_id": project_id,
+            "plan_html": plan_html,
+            "data": json.loads(json_response)
+        }
+    except Exception as e:
+        raise Exception(str(e))
+
+
+async def generate_final_plan(data, token):
+    print(f"Step 1111111")
+    user = await get_user_from_token(token= token)
+    output = ""
+    # async for chunk in ask_question(question=prompt, history=[], use_context=False):
+    #     output += chunk
+    # json_response = parse_and_return_json(output)
+    # json_response = json.loads(json_response)
+    json_response = await extract_data_from_html(data.rough_plan_html)
+    print(f"JSON RESPONSE after extract_data_from_html.......")
+    json_response = json.loads(json_response)
+    project_title = data.project_title
+    if (data.project_title == "" or data.project_title == None):
+        generated_project_title = await generate_project_title(requirements=data.requirements)
+        project_title = generated_project_title.split(":")[0].strip('"')
+    project_name =  project_title
+    # tasks_applications = "".join([phase['name'] for phase in json_response['project_tasks_milestones']['phases']])
+    tasks_applications = generate_task_appplication(json_response['project_tasks_milestones'])
+    business_objectives = ", ".join([obj for obj in json_response['scope_objectives']['objectives']])
+    existing_infrastructure = 'AWS',
+    scalability_performance = ", ".join([item['objective'] for item in json_response['architecture_objectives']])
+    other_requirements = "".join([feature for feature in  data.features])
+    user_id = "e16575cd-e9d3-47d5-b3ba-d3ef612f5683"
+    request_body = {
+        "project_name": project_name,
+        "tasks_applications": tasks_applications,
+        "business_objectives": business_objectives,
+        "existing_infrastructure": "AWS",
+        "scalability_performance":scalability_performance,
+        "security_compliance": scalability_performance,
+        "other_requirements": other_requirements,
+        "user_id": "e16575cd-e9d3-47d5-b3ba-d3ef612f5683",
+    }
+    async with httpx.AsyncClient(timeout=60.0) as client:
+                try:
+                    external_response = await client.post(
+                        "https://auto-board-workspace.vercel.app/api/plan/generate",
+                        json=request_body,
+                        timeout=60.0
+                    )
+                except Exception as e:
+                        raise Exception(f"Error generating auto-board:::::::::{e}")
+                if external_response.status_code != 200:
+                            raise Exception("Error generating auto-board....")
+                else:
+                    response_data = external_response.json()
+                    print(f"Response Data: {response_data}")
+                    print(f"Response Data: {response_data['data']}")
+                    print(f"Response Data: {response_data['data']['id']}")
+                    print(f"First API called.............")
+                    gantt_request_body = {
+                            "projectId": str(response_data['data']['id']),
+                            "userId": "e16575cd-e9d3-47d5-b3ba-d3ef612f5683"
+                    }
+                    print(f"gantt request body: {gantt_request_body}")
+                    try:
+                        kamban = await client.post(
+                                "https://auto-board-workspace.vercel.app/api/kanbans/generate",
+                                json=gantt_request_body,
+                                timeout=60.0
+                        )
+                        external_response = await client.post(
+                                "https://auto-board-workspace.vercel.app/api/gantt/generate",
+                                json=gantt_request_body,
+                                timeout=60.0
+                            )
+                    except Exception as e:
+                         raise Exception(f"Error generating gantt: {e}")
+                    print(f"Second and Third API called.............")
+                    kamban_response = kamban.json()
+                    async with httpx.AsyncClient() as client:
+                        if external_response.status_code == 200:
+                            response_json = external_response.json()
+                            db_instance = ProjectModel(requirements=data.requirements, features=data.features,
+                                            solution_stack = data.solution_stack, rough_plan = data.rough_plan,
+                                            final_plan = json_response, user_id = user.id,
+                                            project_title = project_title,
+                                            gantt_project_id = str(response_data['data']['id']),
+                                            user_uuid ="e16575cd-e9d3-47d5-b3ba-d3ef612f5683",
+                                            ganttDataID=str(response_json['data']['id']),
+                                            boardId=str(kamban_response['board']['id']),
+                                            rough_plan_html=data.rough_plan_html,
+                                            final_plan_html=data.rough_plan_html
+                                        )
+                            await db_instance.save()
+                            print(f"DB Instance: {db_instance.id}")
+                            # str_data = ""
+                            # if isinstance(json_response, dict):
+                            #     str_data = json.dumps(json_response)
+                            # else:
+                            #      str_data = json.loads(json_response)
+                            # await generate_embeddings(data=str_data, project_id=db_instance.id)
+                            print(f"Finalizing............")
+                            return {
+                                "project_title": project_title,
+                                "project_id": int(db_instance.id),   
+                                "data": json_response,
+                                "final_plan": data.rough_plan_html
+                            }
+                        else:
+                            print(f"Gantt Chart Task: External API responded with status code {external_response.status_code}: {external_response.text}")
+                            return {
+                                "success": False,
+                                "status_code": external_response.status_code,
+                                "message": external_response.text
+                            }                        
+
+
+async def update_final_plan_fun(project_id, data, token):
+    try:
+        project , json_response = await asyncio.gather(
+             ProjectModel.get(id=project_id),
+             extract_data_from_html(data.final_plan_html)
+        )
+        project.final_plan_html = data.final_plan_html
+        print(f"saving html content.........")
+        project.final_plan = json.loads(json_response)
+        await project.save()
+        
+        return {
+            "success": True,
+            "message": "Final plan HTML updated successfully.",
+            "project_id": project.id,
+            "final_plan_html": project.final_plan_html
+        }
+
+    except Exception as e:
+        raise Exception(f"Error updating final plan HTML: {str(e)}")

app/helpers/generate_soluction_stack.py

@@ -0,0 +1,39 @@
+from helpers.f5_model import f5_model
+from pydantic import BaseModel, Field
+from typing import List
+
+class StackComponent(BaseModel):
+    service: str
+    description: str
+
+class SoluctionStack(BaseModel):
+    computer_processing: List[StackComponent]
+    data_management_storage: List[StackComponent]
+    network_security: List[StackComponent]
+    app_integration_management: List[StackComponent]
+
+async def generate_soluction_stack(data):
+    prompt = (
+        f"Requirements: {data.requirements}\n"
+        f"Additional Features: {data.additional_feature} \n"
+        "Generate a comprehensive cloud solution stack with the following components:\n"
+        "1. Computer Processing\n"
+        "2. Data Management and Storage\n"
+        "3. Network Security\n"
+        "4. Application Integration and Management"
+    )
+    
+    response = await f5_model.generate_response(prompt)
+    # Parse the response into SoluctionStack structure
+    stack_dict = parse_stack_response(response)
+    return SoluctionStack(**stack_dict)
+
+def parse_stack_response(response: str) -> dict:
+    # Add parsing logic here to convert F5 model output to SoluctionStack format
+    # This is a placeholder implementation
+    return {
+        "computer_processing": [],
+        "data_management_storage": [],
+        "network_security": [],
+        "app_integration_management": []
+    }

app/helpers/plan_chat.py

@@ -0,0 +1,83 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_openai import ChatOpenAI
+from helpers.generate_embbedings import vector_store
+from langchain_aws import ChatBedrock
+import os
+
+def make_prompt(history, prompt, context=None):
+    formatted_history = ""
+
+    if context:
+        formatted_history += f"[CONTEXT] {context} [/CONTEXT]\n"
+
+    for history_item in history:
+        if history_item.from_ == 'user':
+            formatted_history += f"[INST] {history_item.message} [/INST]\n"
+        else:
+            formatted_history += f"{history_item.message}\n"
+
+    formatted_history += f"[INST] {prompt} [/INST]\n"
+
+    return formatted_history
+
+prompt = ChatPromptTemplate.from_template("{prompt}")
+
+model = ChatBedrock(
+    model="mistral.mistral-7b-instruct-v0:2",
+    aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID"),
+    aws_secret_access_key=os.environ.get("AWS_SECRET_ACCESS_KEY"),
+    region=os.environ.get("AWS_DEFAULT_REGION"),
+    max_tokens=8000,
+    temperature=0
+)
+
+output_parser = StrOutputParser()
+
+chain = prompt | model | output_parser
+
+async def ask_question(question: str, history: list = [], project_id=None):
+    """
+    Generate a response for a given question based on history and project-specific context.
+    """
+    try:
+        context = ""
+        if project_id is not None:
+            context = vector_store.similarity_search(
+                query=question, k=4, filter={"project_id": project_id}
+            )
+        
+        prompt = make_prompt(history, question, context)
+
+        stream = chain.astream({"prompt": prompt})
+        async for chunk in stream:
+            yield chunk
+    except Exception as e:
+        raise RuntimeError(f"Error generating response: {str(e)}")
+
+
+gpt_model = ChatOpenAI(
+    temperature=0.7,
+    model='gpt-4o-mini'
+)
+chain = prompt | gpt_model | StrOutputParser()
+
+async def ask_openai(question: str, history: list = []):
+    """
+    Generate a response for a given question based on history and project-specific context.
+    """
+    ai_response = "I am the CloudMod Solutions Architect, an expert in AWS, Azure & GCP. How can I help you?"
+    try:
+        context = ("You are a AI Assistant for CloudMod Soluctions Architect, an expert in AWS, Azure & GCP \n"
+                   "If asked question such as `what the chat does, what they are`\n"
+                   "Answer question as per the context \n\n"
+                   f"Here is the user query : {question}"
+                   f"here is the previous chat history: {history}"
+                   )
+
+        prompt = context
+        stream = chain.astream({"prompt": prompt})
+        async for chunk in stream:
+            yield chunk
+    except Exception as e:
+        raise RuntimeError(f"Error generating response: {str(e)}")

app/helpers/plan_parser.py

@@ -0,0 +1,91 @@
+def parse_plan_sections(content: str) -> dict:
+    """Parse the generated plan content into structured sections."""
+    sections = {
+        "executive_summary": "No content generated",
+        "scope_objectives": "No content generated",
+        "architecture_overview": "No content generated",
+        "component_design": "No content generated",
+        "security_compliance": "No content generated",
+        "deployment_testing": "No content generated",
+        "team_roles": "No content generated",
+        "cost_estimates": "No content generated",
+        "project_phases": "No content generated"
+    }
+    
+    current_section = None
+    lines = content.split('\n')
+    section_content = []
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Check for section headers
+        if line.lower().startswith('1. executive summary') or line.lower().startswith('executive summary'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'executive_summary'
+            section_content = []
+            continue
+        elif line.lower().startswith('2. project scope') or line.lower().startswith('scope'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'scope_objectives'
+            section_content = []
+            continue
+        elif line.lower().startswith('3. architecture') or line.lower().startswith('architecture'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'architecture_overview'
+            section_content = []
+            continue
+        elif line.lower().startswith('4. component') or line.lower().startswith('component'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'component_design'
+            section_content = []
+            continue
+        elif line.lower().startswith('5. security') or line.lower().startswith('security'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'security_compliance'
+            section_content = []
+            continue
+        elif line.lower().startswith('6. deployment') or line.lower().startswith('deployment'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'deployment_testing'
+            section_content = []
+            continue
+        elif line.lower().startswith('7. team') or line.lower().startswith('team'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'team_roles'
+            section_content = []
+            continue
+        elif line.lower().startswith('8. cost') or line.lower().startswith('cost'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'cost_estimates'
+            section_content = []
+            continue
+        elif line.lower().startswith('9. project') or line.lower().startswith('project'):
+            if current_section and section_content:
+                sections[current_section] = '\n'.join(section_content)
+            current_section = 'project_phases'
+            section_content = []
+            continue
+        elif current_section:
+            section_content.append(line)
+    
+    # Add the last section's content
+    if current_section and section_content:
+        sections[current_section] = '\n'.join(section_content)
+    
+    # Clean up empty sections
+    for key, value in sections.items():
+        if not value or value.isspace():
+            sections[key] = "No content generated for this section."
+    
+    return sections 

app/main.py

@@ -1,102 +1,298 @@
-from fastapi import FastAPI, Request, HTTPException
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from .routes import invoices
-from app.db.database import init_db, rate_limiter
-import os
-from fastapi.middleware.cors import CORSMiddleware
-from starlette.middleware.base import BaseHTTPMiddleware
-from dotenv import load_dotenv
+from pydantic import BaseModel
+from app.controllers.f5_model import F5ModelHandler
+from typing import List, Optional
 import logging
-from typing import Callable
-import time
+from app.helpers.plan_parser import parse_plan_sections
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('app.log')
+    ]
+)
 logger = logging.getLogger(__name__)
 
-# Load environment variables
-load_dotenv()
-
-# Get the absolute path to the app directory
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-class RateLimitMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next: Callable):
-        # Get client IP
-        client_ip = request.client.host
-        
-        # Check rate limit
-        if not rate_limiter.is_allowed(client_ip):
-            logger.warning(f"Rate limit exceeded for IP: {client_ip}")
-            raise HTTPException(
-                status_code=429,
-                detail="Too many requests. Please try again later."
-            )
-        
-        # Process request
-        start_time = time.time()
-        response = await call_next(request)
-        process_time = time.time() - start_time
-        
-        # Log request details
-        logger.info(
-            f"Request: {request.method} {request.url.path} "
-            f"Client: {client_ip} "
-            f"Process time: {process_time:.2f}s"
-        )
-        
-        return response
+app = FastAPI(title="F5 Model Test Application")
+templates = Jinja2Templates(directory="app/templates")
 
-app = FastAPI(
-    title="Invoice Generator",
-    description="API for generating invoices",
-    version="1.0.0"
-)
+# Initialize the F5 model
+model_handler = F5ModelHandler()
 
-# Add rate limiting middleware
-app.add_middleware(RateLimitMiddleware)
-
-# Configure CORS with more specific settings
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with specific domains
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-    max_age=3600,  # Cache preflight requests for 1 hour
-)
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: List[ChatMessage]
+    stream: Optional[bool] = False
 
-# Mount static files with absolute path
-app.mount("/static", StaticFiles(directory=os.path.join(BASE_DIR, "app/static")), name="static")
+class FeatureRequest(BaseModel):
+    requirements: str
 
-# Templates with absolute path
-templates = Jinja2Templates(directory=os.path.join(BASE_DIR, "app/templates"))
+class Feature(BaseModel):
+    feature: str
+    short_description: str
 
-# Include routers
-app.include_router(invoices.router)
+class FeaturesResponse(BaseModel):
+    features: List[Feature]
 
-@app.on_event("startup")
-async def startup_event():
-    logger.info("Starting application...")
-    await init_db()
-    logger.info("Application started successfully")
+class ProjectPlanRequest(BaseModel):
+    project_title: str
+    requirements: str
+    features: List[str]
+    platform: str = "AWS"  # Default to AWS
+    additional_requirements: str = ""
 
-@app.on_event("shutdown")
-async def shutdown_event():
-    logger.info("Shutting down application...")
+class ProjectSection(BaseModel):
+    title: str
+    content: str
+
+class ProjectPlan(BaseModel):
+    executive_summary: str
+    scope_objectives: dict
+    architecture_overview: str
+    component_design: List[dict]
+    security_compliance: List[str]
+    deployment_testing: List[str]
+    team_roles: List[dict]
+    cost_estimates: dict
+    project_phases: List[dict]
 
-# Root endpoint to serve the HTML page
 @app.get("/")
-async def root(request: Request):
+async def index(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-# Health check endpoint
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "timestamp": time.time()}
+@app.post("/chat")
+async def chat(request: ChatRequest):
+    try:
+        logger.info(f"Chat request received with {len(request.messages)} messages")
+        
+        # Improve the prompt with better context
+        prompt = (
+            "You are a helpful AI assistant specializing in SaaS applications and software development. "
+            "Please provide detailed and professional responses.\n\n"
+        )
+        
+        for msg in request.messages:
+            if msg.role == "user":
+                prompt += f"[INST] {msg.content} [/INST]\n"
+            else:
+                prompt += f"{msg.content}\n"
+        
+        logger.info(f"Formatted prompt: {prompt}")
+
+        if request.stream:
+            logger.info("Starting streaming response")
+            async def generate():
+                async for chunk in model_handler.stream_response(prompt):
+                    logger.debug(f"Streaming chunk: {chunk}")
+                    yield f"data: {chunk}\n\n"
+            return StreamingResponse(generate(), media_type="text/event-stream")
+        else:
+            response = await model_handler.generate_response(prompt)
+            logger.info(f"Generated response: {response}")
+            return {"response": response}
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate-features", response_model=FeaturesResponse)
+async def generate_features(request: FeatureRequest):
+    try:
+        logger.info(f"Feature generation request received with requirements: {request.requirements}")
+        
+        # Improved prompt for better feature generation
+        prompt = (
+            "You are a SaaS product expert. Generate 20 practical features for a SaaS application.\n"
+            "For each feature:\n"
+            "1. Provide a short, clear feature name\n"
+            "2. Write a concise description explaining its value\n"
+            "Format each feature as:\n"
+            "Feature Name\n"
+            "Clear description of what the feature does and its benefits.\n\n"
+            f"Requirements: {request.requirements}\n\n"
+            "Generate 20 features in this exact format."
+        )
+        
+        logger.info(f"Generated prompt: {prompt}")
+        
+        response = await model_handler.generate_response(prompt)
+        logger.info(f"Model response: {response}")
+        
+        # Parse the response into features
+        features = []
+        lines = response.split('\n')
+        current_feature = None
+        current_description = []
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                if current_feature and current_description:
+                    features.append(Feature(
+                        feature=current_feature,
+                        short_description=' '.join(current_description)
+                    ))
+                    current_feature = None
+                    current_description = []
+            elif not current_feature:
+                current_feature = line
+            else:
+                current_description.append(line)
+        
+        # Add the last feature if exists
+        if current_feature and current_description:
+            features.append(Feature(
+                feature=current_feature,
+                short_description=' '.join(current_description)
+            ))
+        
+        # If no features were parsed, provide fallback features
+        if not features:
+            features = [
+                Feature(
+                    feature="User Management",
+                    short_description="Complete user authentication and authorization system"
+                ),
+                Feature(
+                    feature="Subscription Billing",
+                    short_description="Automated billing and subscription management"
+                ),
+                Feature(
+                    feature="Analytics Dashboard",
+                    short_description="Real-time metrics and usage analytics"
+                ),
+                Feature(
+                    feature="API Integration",
+                    short_description="RESTful API endpoints for third-party integration"
+                ),
+                Feature(
+                    feature="Multi-tenant Architecture",
+                    short_description="Secure data isolation for multiple customers"
+                )
+            ]
+        
+        logger.info(f"Returning features: {features}")
+        return FeaturesResponse(features=features)
+    except Exception as e:
+        logger.error(f"Error in generate-features endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate-plan")
+async def generate_plan(request: ProjectPlanRequest):
+    try:
+        logger.info(f"Plan generation request received for project: {request.project_title}")
+        
+        # Enhanced prompt for more detailed output
+        prompt = f"""Generate a comprehensive technical project plan for '{request.project_title}' with detailed sections.
+        Include specific {request.platform} services and implementation details in each section.
+
+        1. Executive Summary
+        - Provide a detailed overview of the project (4-5 paragraphs)
+        - Include project goals, target users, and key outcomes
+        - Highlight main {request.platform} services to be used
+        - Explain expected business impact
+
+        2. Project Scope and Objectives
+        - Define detailed scope including:
+          * Core functionalities
+          * System boundaries
+          * Integration points
+        - List at least 5 specific objectives
+        - Include measurable success criteria
+
+        3. Architecture Overview
+        - Detailed {request.platform} architecture including:
+          * Frontend architecture
+          * Backend services
+          * Database design
+          * Integration patterns
+          * Network topology
+        - Explain how components interact
+        - Include scalability considerations
+
+        4. Component Design
+        - Detail at least 3 core components with:
+          * Purpose and functionality
+          * Technical specifications
+          * Data flow
+          * Integration points
+          * Performance requirements
+
+        5. Security and Compliance
+        - List specific {request.platform} security services
+        - Detail authentication and authorization
+        - Describe data protection measures
+        - Include compliance requirements
+        - Specify security monitoring
+
+        6. Deployment, Testing, and Monitoring
+        - Detailed CI/CD pipeline
+        - Test strategy including:
+          * Unit testing
+          * Integration testing
+          * Performance testing
+        - Monitoring setup with {request.platform} tools
+        - Alerting and logging strategy
+
+        7. Team Roles and Skills
+        - List all required roles
+        - Detail specific skills needed
+        - Include {request.platform} certifications
+        - Define team structure
+        - Specify responsibilities
+
+        8. Cost Estimates and Optimization
+        - Break down {request.platform} service costs
+        - Resource optimization strategies
+        - Scaling considerations
+        - Cost monitoring approach
+        - Budget optimization tips
+
+        9. Project Tasks and Milestones
+        - Detailed project phases
+        - Specific tasks for each phase
+        - Timeline estimates
+        - Dependencies
+        - Critical path items
+
+        Project Requirements:
+        {request.requirements}
+
+        Features to implement:
+        {', '.join(request.features)}
+
+        Additional Requirements:
+        {request.additional_requirements}
+
+        Generate a detailed plan following this structure with specific {request.platform} implementation details."""
+        
+        logger.info("Generating plan with model...")
+        response = await model_handler.generate_response(prompt)
+        logger.info(f"Response generated successfully: {response[:100]}...")
+        
+        # Parse the response into structured sections
+        sections = parse_plan_sections(response)
+        
+        logger.info("Plan generated successfully")
+        return {
+            "project_title": request.project_title,
+            "sections": sections,
+            "raw_content": response
+        }
+        
+    except Exception as e:
+        logger.error(f"Error generating plan: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
 
-@app.get("/history")
-async def history_page(request: Request):
-    return templates.TemplateResponse("history.html", {"request": request})
-    

app/models/project_plan.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class ProjectPlanRequest(BaseModel):
+    project_title: str
+    requirements: str
+    features: List[str]
+    platform: str = "AWS"  # Default to AWS
+    additional_requirements: str = ""
+
+class ProjectSection(BaseModel):
+    title: str
+    content: str
+
+class ProjectPlan(BaseModel):
+    executive_summary: str
+    scope_objectives: dict
+    architecture_overview: str
+    component_design: List[dict]
+    security_compliance: List[str]
+    deployment_testing: List[str]
+    team_roles: List[dict]
+    cost_estimates: dict
+    project_phases: List[dict] 

app/services/flan_t5_service.py

@@ -0,0 +1,18 @@
+from transformers import T5ForConditionalGeneration, T5Tokenizer
+
+class FlanT5Service:
+    def __init__(self):
+        self.model_name = "google/flan-t5-base"
+        self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
+        self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
+
+    async def generate_response(self, prompt: str, max_length: int = 512) -> str:
+        inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
+        outputs = self.model.generate(
+            **inputs,
+            max_length=max_length,
+            num_beams=4,
+            temperature=0.7,
+            top_p=0.9
+        )
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

app/services/scraper_service.py

@@ -0,0 +1,45 @@
+from httpx import AsyncClient
+from bs4 import BeautifulSoup
+from typing import Tuple
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+class ScraperService:
+    def __init__(self):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=20,
+            length_function=len,
+            is_separator_regex=False,
+        )
+
+    async def scrape_website(self, url: str) -> str:
+        async with AsyncClient() as client:
+            chrome_headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+            }
+            response = await client.get(url, headers=chrome_headers)
+            return response.text
+
+    def extract_text_from_html(self, html: str) -> str:
+        soup = BeautifulSoup(html, 'html.parser')
+        
+        # Remove script and style elements
+        for element in soup(['script', 'style', 'header', 'footer', 'nav']):
+            element.decompose()
+        
+        text = soup.get_text(separator='\n', strip=True)
+        return text
+
+    async def scrape_and_process(self, url: str) -> Tuple[str, list]:
+        # Scrape the website
+        html = await self.scrape_website(url)
+        
+        # Extract text
+        text = self.extract_text_from_html(html)
+        
+        # Split into chunks
+        documents = self.text_splitter.create_documents([text])
+        
+        return text, documents

app/static/js/main.js

@@ -0,0 +1,45 @@
+document.addEventListener('DOMContentLoaded', function() {
+    const form = document.getElementById('scrapeForm');
+    const loadingIndicator = document.getElementById('loadingIndicator');
+    const results = document.getElementById('results');
+    const resultContent = document.getElementById('resultContent');
+
+    form.addEventListener('submit', async function(e) {
+        e.preventDefault();
+        
+        const url = document.getElementById('url').value;
+        const promptTemplate = document.getElementById('promptTemplate').value;
+        
+        loadingIndicator.classList.remove('hidden');
+        results.classList.add('hidden');
+
+        try {
+            const response = await fetch('/api/scrape', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ 
+                    url: url,
+                    prompt_template: promptTemplate
+                })
+            });
+
+            const data = await response.json();
+            
+            if (data.success) {
+                resultContent.textContent = data.result;
+            } else {
+                resultContent.textContent = 'Failed to analyze content: ' + data.detail;
+            }
+            
+            results.classList.remove('hidden');
+        } catch (error) {
+            console.error('Error:', error);
+            resultContent.textContent = 'An error occurred while processing your request.';
+            results.classList.remove('hidden');
+        } finally {
+            loadingIndicator.classList.add('hidden');
+        }
+    });
+});

app/templates/index.html

@@ -3,1407 +3,372 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Invoice Generator</title>
-    <!-- Bootstrap CSS -->
-    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet">
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <title>F5 Model Test Interface</title>
+    <script src="https://cdn.tailwindcss.com"></script>
     <style>
-        :root {
-            --primary-color: #2c3e50;
-            --secondary-color: #34495e;
-            --accent-color: #3498db;
-            --light-gray: #f8f9fa;
-            --border-radius: 8px;
-        }
-
-        body {
-            background-color: #f5f6fa;
-            color: var(--primary-color);
-        }
-
-        .container {
-            max-width: 1400px;
-            padding: 2rem;
-        }
-
-        .card {
-            border: none;
-            box-shadow: 0 2px 15px rgba(0, 0, 0, 0.1);
-            border-radius: var(--border-radius);
-            margin-bottom: 1.5rem;
-        }
-
-        .card-header {
-            background-color: var(--primary-color);
-            color: white;
-            border-radius: var(--border-radius) var(--border-radius) 0 0 !important;
-            padding: 1rem;
-            font-weight: 500;
-        }
-
-        .card-body {
-            padding: 1.5rem;
-        }
-
-        .form-control {
-            border: 1px solid #dee2e6;
-            border-radius: var(--border-radius);
-            padding: 0.75rem;
-            transition: all 0.3s ease;
-        }
-
-        .form-control:focus {
-            border-color: var(--accent-color);
-            box-shadow: 0 0 0 0.2rem rgba(52, 152, 219, 0.25);
-        }
-
-        .btn-primary {
-            background-color: var(--accent-color);
-            border: none;
-            padding: 0.75rem 1.5rem;
-            border-radius: var(--border-radius);
-            transition: all 0.3s ease;
-        }
-
-        .btn-primary:hover {
-            background-color: #2980b9;
-            transform: translateY(-1px);
-        }
-
-        .btn-success {
-            background-color: #2ecc71;
-            border: none;
-            padding: 1rem 2rem;
-            border-radius: var(--border-radius);
-            font-weight: 500;
-            transition: all 0.3s ease;
-        }
-
-        .btn-success:hover {
-            background-color: #27ae60;
-            transform: translateY(-2px);
-        }
-
-        .table {
-            background-color: white;
-            border-radius: var(--border-radius);
-            overflow: hidden;
-        }
-
-        .table-primary {
-            background-color: var(--primary-color);
-            color: white;
-        }
-
-        .table th {
-            font-weight: 500;
-            padding: 1rem;
-        }
-
-        .table td {
-            padding: 0.75rem;
-            vertical-align: middle;
-        }
-
-        .section-title {
-            background-color: var(--secondary-color);
-            color: white;
-            padding: 1rem;
-            margin: 2rem 0 1rem;
-            border-radius: var(--border-radius);
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-        }
-
-        .section-title h4 {
-            margin: 0;
-            font-weight: 500;
-        }
-
-        .btn-group {
-            background-color: white;
-            border-radius: var(--border-radius);
-            padding: 0.25rem;
-        }
-
-        .btn-check + .btn-outline-primary {
-            color: var(--primary-color);
-            border-color: var(--primary-color);
-        }
-
-        .btn-check:checked + .btn-outline-primary {
-            background-color: var (--primary-color);
-            color: white;
-        }
-
-        .modal-content {
-            border-radius: var(--border-radius);
-            border: none;
-            box-shadow: 0 5px 25px rgba(0, 0, 0, 0.2);
-        }
-
-        .modal-header {
-            background-color: var(--primary-color);
-            color: white;
-            border-radius: var(--border-radius) var (--border-radius) 0 0;
-        }
-
-        .btn-close {
-            filter: brightness(0) invert(1);
-        }
-
-        .btn-danger {
-            background-color: #e74c3c;
-            border: none;
-            border-radius: var(--border-radius);
-            transition: all 0.3s ease;
-        }
-
-        .btn-danger:hover {
-            background-color: #c0392b;
-        }
-
-        /* Responsive adjustments */
-        @media (max-width: 768px) {
-            .container {
-                padding: 1rem;
-            }
-
-            .card-body {
-                padding: 1rem;
-            }
-
-            .btn {
-                padding: 0.5rem 1rem;
-            }
-        }
-
-        .preview-modal .modal-dialog {
-            max-width: 80%;
-        }
-        .status-pending { color: #ffc107; }
-        .status-completed { color: #28a745; }
-
-        header {
-            background: linear-gradient(135deg, #0d6efd 0%, #0a58ca 100%);
-        }
-        
-        header .btn-light {
-            transition: all 0.3s ease;
-            border-radius: 20px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        
-        header .btn-light:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 4px 8px rgba(0,0,0,0.2);
-        }
-        
-        header h1 {
-            font-size: 2rem;
-            text-shadow: 1px 1px 2px rgba(0,0,0,0.1);
+        .loading {
+            display: none;
+            position: relative;
+            width: 80px;
+            height: 80px;
+            margin: 0 auto;
+        }
+        .loading div {
+            position: absolute;
+            width: 16px;
+            height: 16px;
+            border-radius: 50%;
+            background: #4B5563;
+            animation: loading 1.2s linear infinite;
+        }
+        .loading div:nth-child(1) {
+            top: 8px;
+            left: 8px;
+            animation-delay: 0s;
+        }
+        .loading div:nth-child(2) {
+            top: 8px;
+            left: 32px;
+            animation-delay: -0.4s;
+        }
+        .loading div:nth-child(3) {
+            top: 8px;
+            left: 56px;
+            animation-delay: -0.8s;
+        }
+        @keyframes loading {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
         }
     </style>
 </head>
-<body class="bg-light">
-    <!-- Header -->
-    <header class="bg-primary py-4 mb-4 shadow-sm">
-        <div class="container">
-            <div class="row align-items-center justify-content-between">
-                <div class="col-md-3">
-                    <img src="/static/logo.png" alt="Logo" height="50" class="img-fluid">
+<body class="bg-gray-100">
+    <div class="container mx-auto px-4 py-8">
+        <h1 class="text-3xl font-bold mb-8">F5 Model Test Interface</h1>
+
+        <!-- Project Plan Generation Section -->
+        <div class="bg-white rounded-lg shadow-md p-6 mb-8">
+            <h2 class="text-xl font-semibold mb-4">Project Plan Generation</h2>
+            <div class="space-y-4">
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Project Title</label>
+                    <input type="text" id="projectTitle" class="w-full border rounded px-3 py-2" placeholder="Enter project title">
                 </div>
-                <div class="col-md-6 text-center">
-                    <h1 class="text-white mb-0 fw-bold">Générateur de Devis</h1>
-                    <a href="/history" class="btn btn-light mt-2 px-4">
-                        <i class="fas fa-history"></i> Historique des Devis
-                    </a>
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Requirements</label>
+                    <textarea id="planRequirements" class="w-full border rounded px-3 py-2 h-32" placeholder="Enter project requirements"></textarea>
                 </div>
-                <div class="col-md-3 text-end">
-                    <div class="text-white">
-                        <small class="d-block">Date: <span id="currentDate"></span></small>
-                        <small class="d-block">Version 1.0</small>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </header>
-
-    <div class="container">
-        <!-- Main Content -->
-        <div class="row">
-            <div class="col-12">
-                <div class="card shadow-sm mb-4">
-                    <div class="card-body">
-                        <form id="invoiceForm">
-                            <!-- Client and Invoice Information -->
-                            <div class="row mb-4">
-                                <!-- Client Information Card -->
-                                <div class="col-md-6">
-                                    <div class="card h-100">
-                                        <div class="card-header d-flex justify-content-between align-items-center">
-                                            <h5 class="mb-0">Information Client</h5>
-                                            <i class="fas fa-user"></i>
-                                        </div>
-                                        <div class="card-body">
-                                            <div class="mb-3">
-                                                <label for="clientName" class="form-label">Nom du Client</label>
-                                                <input type="text" class="form-control" id="clientName" required>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="clientPhone" class="form-label">Téléphone</label>
-                                                <div class="input-group">
-                                                    <input type="tel" class="form-control" id="clientPhone" name="phone1" placeholder="Premier numéro" required>
-                                                    <span class="input-group-text">/</span>
-                                                    <input type="tel" class="form-control" id="clientPhone2" name="phone2" placeholder="Deuxième numéro (optionnel)">
-                                                </div>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="clientAddress" class="form-label">Adresse</label>
-                                                <input type="text" class="form-control" id="clientAddress" required>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="plancher" class="form-label">PLANCHER</label>
-                                                <input type="text" class="form-control" id="plancher" placeholder="PH RDC" value="PH RDC">
-                                            </div>
-                                            <div class="mb-3">
-                                                <label class="form-label">Type Client</label>
-                                                <div class="btn-group w-100" role="group">
-                                                    <input type="radio" class="btn-check" name="clientType" id="EE" value="EE" autocomplete="off">
-                                                    <label class="btn btn-outline-primary" for="EE">EE</label>
-
-                                                    <input type="radio" class="btn-check" name="clientType" id="MED" value="MED" autocomplete="off">
-                                                    <label class="btn btn-outline-primary" for="MED">MED</label>
-
-                                                    <input type="radio" class="btn-check" name="clientType" id="AM" value="AM" autocomplete="off">
-                                                    <label class="btn btn-outline-primary" for="AM">AM</label>
-
-                                                    <input type="radio" class="btn-check" name="clientType" id="DIV" value="DIV" autocomplete="off">
-                                                    <label class="btn btn-outline-primary" for="DIV">DIV</label>
-                                                </div>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label class="form-label">Commercial</label>
-                                                <select class="form-select" id="commercial" required>
-                                                    <option value="">Sélectionner un commercial</option>
-                                                    <option value="khaled">Khaled</option>
-                                                    <option value="salah">Salah</option>
-                                                    <option value="ismail">Ismail</option>
-                                                    <option value="jamal">Jamal</option>
-                                                    <option value="divers">Divers</option>
-                                                </select>
-                                            </div>
-                                        </div>
-                                    </div>
-                                </div>
-
-                                <!-- Invoice Information Card -->
-                                <div class="col-md-6">
-                                    <div class="card h-100">
-                                        <div class="card-header d-flex justify-content-between align-items-center">
-                                            <h5 class="mb-0">Information Devis</h5>
-                                            <i class="fas fa-file-invoice"></i>
-                                        </div>
-                                        <div class="card-body">
-                                            <div class="mb-3">
-                                                <label for="invoiceNumber" class="form-label">N° Devis</label>
-                                                <input type="text" class="form-control" id="invoiceNumber" required>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="date" class="form-label">Date</label>
-                                                <input type="date" class="form-control" id="date" readonly>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="project" class="form-label">Type d'ouvrage</label>
-                                                <input type="text" class="form-control" id="project" required>
-                                            </div>
-                                        </div>
-                                    </div>
-                                </div>
-                            </div>
-
-                            <!-- Items Sections -->
-                            <div class="card shadow-sm mb-4">
-                                <div class="card-body">
-                                    <!-- Poutrelles Section -->
-                                    <div class="section-title">
-                                        <h4>POUTRELLES</h4>
-                                        <button type="button" class="btn btn-light" id="addPoutrelles">
-                                            <i class="fas fa-plus"></i> Ajouter Poutrelle
-                                        </button>
-                                    </div>
-                                    <div class="table-responsive">
-                                        <table class="table table-bordered table-hover">
-                                            <thead class="table-primary">
-                                                <tr>
-                                                    <th style="width: 30%">Description</th>
-                                                    <th style="width: 10%">Unité</th>
-                                                    <th style="width: 10%">Quantité</th>
-                                                    <th style="width: 15%">Longueur</th>
-                                                    <th style="width: 15%">P.U</th>
-                                                    <th style="width: 15%">Total HT</th>
-                                                    <th style="width: 5%"></th>
-                                                </tr>
-                                            </thead>
-                                            <tbody id="poutrellesTable"></tbody>
-                                        </table>
-                                    </div>
-
-                                    <!-- Hourdis Section -->
-                                    <div class="section-title mt-4">
-                                        <h4>HOURDIS</h4>
-                                        <button type="button" class="btn btn-light" id="addHourdis">
-                                            <i class="fas fa-plus"></i> Ajouter Hourdis
-                                        </button>
-                                    </div>
-                                    <div class="table-responsive">
-                                        <table class="table table-bordered table-hover">
-                                            <thead class="table-primary">
-                                                <tr>
-                                                    <th style="width: 30%">Description</th>
-                                                    <th style="width: 10%">Unité</th>
-                                                    <th style="width: 10%">Quantité</th>
-                                                    <th style="width: 15%">Longueur</th>
-                                                    <th style="width: 15%">P.U</th>
-                                                    <th style="width: 15%">Total HT</th>
-                                                    <th style="width: 5%"></th>
-                                                </tr>
-                                            </thead>
-                                            <tbody id="hourdisTable"></tbody>
-                                        </table>
-                                    </div>
-
-                                    <!-- Panneau Section -->
-                                    <div class="section-title mt-4">
-                                        <h4>PANNEAU TREILLIS SOUDES</h4>
-                                        <button type="button" class="btn btn-light" id="addPanneau">
-                                            <i class="fas fa-plus"></i> Ajouter Panneau
-                                        </button>
-                                    </div>
-                                    <div class="table-responsive">
-                                        <table class="table table-bordered table-hover">
-                                            <thead class="table-primary">
-                                                <tr>
-                                                    <th style="width: 30%">Description</th>
-                                                    <th style="width: 10%">Unité</th>
-                                                    <th style="width: 10%">Quantité</th>
-                                                    <th style="width: 15%">Longueur</th>
-                                                    <th style="width: 15%">P.U</th>
-                                                    <th style="width: 15%">Total HT</th>
-                                                    <th style="width: 5%"></th>
-                                                </tr>
-                                            </thead>
-                                            <tbody id="panneauTable"></tbody>
-                                        </table>
-                                    </div>
-
-                                    <!-- Agglos Section -->
-                                    <div class="section-title mt-4">
-                                        <h4>AGGLOS</h4>
-                                        <button type="button" class="btn btn-light" id="addAgglos">
-                                            <i class="fas fa-plus"></i> Ajouter Agglos
-                                        </button>
-                                    </div>
-                                    <div class="table-responsive">
-                                        <table class="table table-bordered table-hover">
-                                            <thead class="table-primary">
-                                                <tr>
-                                                    <th style="width: 30%">Description</th>
-                                                    <th style="width: 10%">Unité</th>
-                                                    <th style="width: 10%">Quantité</th>
-                                                    <th style="width: 15%">Longueur</th>
-                                                    <th style="width: 15%">P.U</th>
-                                                    <th style="width: 15%">Total HT</th>
-                                                    <th style="width: 5%"></th>
-                                                </tr>
-                                            </thead>
-                                            <tbody id="agglosTable"></tbody>
-                                        </table>
-                                    </div>
-                                </div>
-                            </div>
-
-                            <!-- Totals Section -->
-                            <div class="row">
-                                <div class="col-md-6">
-                                    <!-- Empty for spacing -->
-                                </div>
-                                <div class="col-md-6">
-                                    <div class="card shadow-sm">
-                                        <div class="card-header">
-                                            <h5 class="mb-0">Totaux</h5>
-                                        </div>
-                                        <div class="card-body">
-                                            <div class="mb-3 form-check form-switch">
-                                                <input class="form-check-input" type="checkbox" id="tvaSwitch" checked>
-                                                <label class="form-check-label" for="tvaSwitch">Appliquer TVA 20%</label>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="totalHT" class="form-label">Total HT</label>
-                                                <input type="number" class="form-control" id="totalHT" readonly>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="tax" class="form-label">TVA 20%</label>
-                                                <input type="number" class="form-control" id="tax" readonly>
-                                            </div>
-                                            <div class="mb-3">
-                                                <label for="totalTTC" class="form-label">Total TTC</label>
-                                                <input type="number" class="form-control" id="totalTTC" readonly>
-                                            </div>
-                                        </div>
-                                    </div>
-                                </div>
-                            </div>
-
-                            <!-- Submit Button -->
-                            <div class="d-grid gap-2 col-md-6 mx-auto mt-4">
-                                <div class="row">
-                                    <div class="col-md-6">
-                                        <button type="submit" class="btn btn-success btn-lg w-100">
-                                            <i class="fas fa-file-pdf"></i> Générer PDF
-                                        </button>
-                                    </div>
-                                    <div class="col-md-6">
-                                        <button type="button" class="btn btn-primary btn-lg w-100" id="generateExcel">
-                                            <i class="fas fa-file-excel"></i> Générer Excel
-                                        </button>
-                                    </div>
-                                </div>
-                            </div>
-                        </form>
-                    </div>
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Features (comma-separated)</label>
+                    <input type="text" id="planFeatures" class="w-full border rounded px-3 py-2" placeholder="Feature 1, Feature 2, Feature 3">
                 </div>
-            </div>
-        </div>
-    </div>
-
-    <!-- Add Font Awesome for icons -->
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
-
-    <!-- Poutrelles Modal -->
-    <div class="modal fade" id="poutrellesModal" tabindex="-1">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title">Sélectionner Poutrelle</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Platform</label>
+                    <select id="platform" class="w-full border rounded px-3 py-2">
+                        <option value="AWS">AWS</option>
+                        <option value="Azure">Azure</option>
+                        <option value="GCP">Google Cloud</option>
+                    </select>
                 </div>
-                <div class="modal-body">
-                    <div class="table-responsive">
-                        <table class="table">
-                            <thead>
-                                <tr>
-                                    <th>Description</th>
-                                    <th>Unité</th>
-                                    <th>Quantité</th>
-                                    <th>Longueur</th>
-                                    <th>P.U</th>
-                                    <th>Action</th>
-                                </tr>
-                            </thead>
-                            <tbody></tbody>
-                        </table>
-                    </div>
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Additional Requirements</label>
+                    <textarea id="additionalRequirements" class="w-full border rounded px-3 py-2 h-24" placeholder="Enter any additional requirements"></textarea>
                 </div>
+                <button onclick="generatePlan()" class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">
+                    Generate Plan
+                </button>
             </div>
-        </div>
-    </div>
-
-    <!-- Hourdis Modal -->
-    <div class="modal fade" id="hourdisModal" tabindex="-1">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title">Sélectionner Hourdis</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
-                </div>
-                <div class="modal-body">
-                    <div class="table-responsive">
-                        <table class="table">
-                            <thead>
-                                <tr>
-                                    <th>Description</th>
-                                    <th>Unité</th>
-                                    <th>Quantité</th>
-                                    <th>Longueur</th>
-                                    <th>P.U</th>
-                                    <th>Action</th>
-                                </tr>
-                            </thead>
-                            <tbody></tbody>
-                        </table>
-                    </div>
-                </div>
+            <div id="planLoading" class="loading mt-4">
+                <div></div>
+                <div></div>
+                <div></div>
             </div>
-        </div>
-    </div>
-
-    <!-- Panneau Modal -->
-    <div class="modal fade" id="panneauModal" tabindex="-1">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title">Sélectionner Panneau</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
-                </div>
-                <div class="modal-body">
-                    <div class="table-responsive">
-                        <table class="table">
-                            <thead>
-                                <tr>
-                                    <th>Description</th>
-                                    <th>Unité</th>
-                                    <th>Quantité</th>
-                                    <th>Longueur</th>
-                                    <th>P.U</th>
-                                    <th>Action</th>
-                                </tr>
-                            </thead>
-                            <tbody></tbody>
-                        </table>
-                    </div>
-                </div>
+            <div id="planOutput" class="mt-6 bg-gray-50 rounded p-4 hidden">
+                <h3 class="text-lg font-semibold mb-2" id="planTitle"></h3>
+                <div id="planSections" class="space-y-4"></div>
             </div>
         </div>
-    </div>
 
-    <!-- Add Agglos Modal -->
-    <div class="modal fade" id="agglosModal" tabindex="-1">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title">Sélectionner Agglos</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        <!-- Chat Section -->
+        <div class="bg-white rounded-lg shadow-md p-6 mb-8">
+            <h2 class="text-xl font-semibold mb-4">Chat Test</h2>
+            <div class="mb-4">
+                <div id="chatHistory" class="bg-gray-50 rounded p-4 h-64 overflow-y-auto mb-4"></div>
+                <div id="chatLoading" class="loading mb-4">
+                    <div></div>
+                    <div></div>
+                    <div></div>
                 </div>
-                <div class="modal-body">
-                    <div class="table-responsive">
-                        <table class="table">
-                            <thead>
-                                <tr>
-                                    <th>Description</th>
-                                    <th>Unité</th>
-                                    <th>Quantité</th>
-                                    <th>Longueur</th>
-                                    <th>P.U</th>
-                                    <th>Action</th>
-                                </tr>
-                            </thead>
-                            <tbody></tbody>
-                        </table>
-                    </div>
+                <div class="flex gap-2">
+                    <input type="text" id="chatInput" 
+                           class="flex-1 border rounded px-3 py-2" 
+                           placeholder="Type your message...">
+                    <button onclick="sendMessage()" 
+                            class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">
+                        Send
+                    </button>
+                    <label class="flex items-center gap-2">
+                        <input type="checkbox" id="streamToggle">
+                        Stream
+                    </label>
                 </div>
             </div>
         </div>
-    </div>
 
-    
-    <!-- Confirmation Modal -->
-<div class="modal fade" id="confirmationModal" tabindex="-1">
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h5 class="modal-title">Article Existant</h5>
-                <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
-            </div>
-            <div class="modal-body">
-                <p>Cet article existe déjà dans le tableau. Que souhaitez-vous faire ?</p>
+        <!-- Feature Generation Section -->
+        <div class="bg-white rounded-lg shadow-md p-6">
+            <h2 class="text-xl font-semibold mb-4">Feature Generation Test</h2>
+            <div class="mb-4">
+                <textarea id="requirementsInput" 
+                         class="w-full border rounded p-3 mb-4 h-32" 
+                         placeholder="Enter requirements..."></textarea>
+                <button onclick="generateFeatures()" 
+                        class="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600">
+                    Generate Features
+                </button>
             </div>
-            <div class="modal-footer">
-                <button type="button" class="btn btn-danger" id="replaceItem">Remplacer</button>
-                <button type="button" class="btn btn-warning" id="addItem">Ajouter</button>
-                <button type="button" class="btn btn-info" id="sumItem">Ajouter et Somme</button>
-                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Annuler</button>
+            <div id="featuresLoading" class="loading mb-4">
+                <div></div>
+                <div></div>
+                <div></div>
             </div>
+            <div id="featuresOutput" class="bg-gray-50 rounded p-4 min-h-32"></div>
         </div>
     </div>
-</div>
 
-
-    <!-- Bootstrap JS -->
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
-    
     <script>
-        // Define default items at the start of your script
-        const defaultItems = {
-            poutrelles: [
-                { description: 'PCP 158B SISMIQUE', unit: 'ML', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'PCP 158B', unit: 'ML', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'PCP 158', unit: 'ML', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'PCP 130', unit: 'ML', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'PCP 110', unit: 'ML', quantity: 0, length: 0, unit_price: 0 }
-            ],
-            hourdis: [
-                { description: 'HOURDIS 13+4', unit: 'U', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'HOURDIS 16+4', unit: 'U', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'HOURDIS 20+4', unit: 'U', quantity: 0, length: 0, unit_price: 0 }
-            ],
-            panneaux: [
-                { description: 'PTS 3.5X2.1', unit: 'U', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'PTS 4.2X2.1', unit: 'U', quantity: 0, length: 0, unit_price: 0 }
-            ],
-            agglos: [
-                { description: 'AGGLOS 15', unit: 'U', quantity: 0, length: 0, unit_price: 0 },
-                { description: 'AGGLOS 20', unit: 'U', quantity: 0, length: 0, unit_price: 0 }
-            ]
-        };
+        let chatHistory = [];
 
-        // Add this function at the start of your script, after defaultItems definition
-        function adjustToNearestStep(input, step) {
-            // If this is a quantity input, force integer
-            if (input.name === "quantity") {
-                const value = parseInt(input.value) || 0;
-                input.value = value;
-            } else {
-                // For other inputs (like length), use decimal step
-                const value = parseFloat(input.value);
-                if (!isNaN(value)) {
-                    const nearestStep = Math.round(value / step) * step;
-                    input.value = nearestStep.toFixed(2);
-                }
-            }
+        async function sendMessage() {
+            const input = document.getElementById('chatInput');
+            const message = input.value.trim();
+            if (!message) return;
+
+            // Show loading indicator
+            document.getElementById('chatLoading').style.display = 'block';
             
-            // Only call updateTotal if we're in a table row
-            const row = input.closest('tr');
-            if (row) {
-                updateTotal(input);
-            }
-        }
+            // Add user message to chat
+            appendMessage('user', message);
+            input.value = '';
 
-        function updateTotal(input) {
+            const streamMode = document.getElementById('streamToggle').checked;
             try {
-                const row = input.closest('tr');
-                if (!row) return;
+                if (streamMode) {
+                    const response = await fetch('/chat', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            messages: chatHistory,
+                            stream: true
+                        })
+                    });
 
-                // Get all required inputs, with null checks
-                const quantityInput = row.querySelector('input[name="quantity"]');
-                const lengthInput = row.querySelector('input[name="length"]');
-                const unitPriceInput = row.querySelector('input[name="unitPrice"]');
-                const totalInput = row.querySelector('input[name="totalHT"]');
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let assistantMessage = '';
 
-                // Only proceed if all required inputs are found
-                if (quantityInput && lengthInput && unitPriceInput && totalInput) {
-                    const quantity = parseFloat(quantityInput.value) || 0;
-                    const length = parseFloat(lengthInput.value) || 0;
-                    const unitPrice = parseFloat(unitPriceInput.value) || 0;
-                    const total = (quantity * length * unitPrice).toFixed(2);
-                    totalInput.value = total;
-                    updateGrandTotal();
+                    while (true) {
+                        const { value, done } = await reader.read();
+                        if (done) break;
+                        
+                        const chunk = decoder.decode(value);
+                        const lines = chunk.split('\n');
+                        for (const line of lines) {
+                            if (line.startsWith('data: ')) {
+                                const content = line.slice(6);
+                                assistantMessage += content;
+                                updateLastMessage('assistant', assistantMessage);
+                            }
+                        }
+                    }
+                } else {
+                    const response = await fetch('/chat', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            messages: chatHistory,
+                            stream: false
+                        })
+                    });
+                    const data = await response.json();
+                    appendMessage('assistant', data.response);
                 }
             } catch (error) {
-                console.error('Error in updateTotal:', error);
+                console.error('Error:', error);
+                appendMessage('system', 'Error: Failed to get response');
+            } finally {
+                // Hide loading indicator
+                document.getElementById('chatLoading').style.display = 'none';
             }
         }
 
-        // Function to update the grand total
-        function updateGrandTotal() {
-            try {
-                const totalHT = Array.from(document.querySelectorAll('input[name="totalHT"]'))
-                    .reduce((sum, input) => sum + (parseFloat(input.value) || 0), 0);
-                
-                const formattedTotalHT = totalHT.toFixed(2);
-                const tvaEnabled = document.querySelector("#tvaSwitch")?.checked;
-                
-                const tax = tvaEnabled ? (totalHT * 0.20).toFixed(2) : "0.00";
-                const totalTTC = tvaEnabled ? (totalHT * 1.20).toFixed(2) : formattedTotalHT;
-                
-                const totalHTInput = document.querySelector("#totalHT");
-                const taxInput = document.querySelector("#tax");
-                const totalTTCInput = document.querySelector("#totalTTC");
+        async function generateFeatures() {
+            const requirements = document.getElementById('requirementsInput').value.trim();
+            if (!requirements) return;
 
-                if (totalHTInput) totalHTInput.value = formattedTotalHT;
-                if (taxInput) taxInput.value = tax;
-                if (totalTTCInput) totalTTCInput.value = totalTTC;
+            // Show loading indicator
+            document.getElementById('featuresLoading').style.display = 'block';
+            document.getElementById('featuresOutput').innerHTML = '';
+
+            try {
+                const response = await fetch('/generate-features', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ requirements })
+                });
+                const data = await response.json();
+                displayFeatures(data.features);
             } catch (error) {
-                console.error('Error in updateGrandTotal:', error);
+                console.error('Error:', error);
+                document.getElementById('featuresOutput').innerHTML = 
+                    '<p class="text-red-500">Error generating features</p>';
+            } finally {
+                // Hide loading indicator
+                document.getElementById('featuresLoading').style.display = 'none';
             }
         }
 
-        document.addEventListener("DOMContentLoaded", function() {
-            const poutrellesTable = document.getElementById("poutrellesTable");
-            const hourdisTable = document.getElementById("hourdisTable");
-            const panneauTable = document.getElementById("panneauTable");
-            const agglosTable = document.getElementById("agglosTable");
-            const invoiceForm = document.getElementById("invoiceForm");
-            const invoiceNumberInput = document.getElementById("invoiceNumber");
+        function appendMessage(role, content) {
+            chatHistory.push({ role, content });
+            updateChatDisplay();
+        }
 
-            // Default items data - Reset all default values to zero
-            const defaultItems = {
-                poutrelles: [
-                    { description: "PCP 114N", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 113N", unit: "ML", quantity: 0, length: 0, unit_price: 0 }
-                ],
-                hourdis: [
-                    { description: "HOURDIS TYPE 12", unit: "U", quantity: 0, length: 0, unit_price: 0 }
-                ],
-                panneaux: [
-                    { description: "PTS SISMIQUE 5*3,5", unit: "U", quantity: 0, length: 0, unit_price: 0 }
-                ]
-            };
+        function updateLastMessage(role, content) {
+            if (chatHistory.length > 0 && chatHistory[chatHistory.length - 1].role === role) {
+                chatHistory[chatHistory.length - 1].content = content;
+            } else {
+                chatHistory.push({ role, content });
+            }
+            updateChatDisplay();
+        }
 
-            
-            // Function to add a new item row
-            function addItemRow(item, table) {
-                console.log('Adding item to table:', item);
+        function updateChatDisplay() {
+            const chatDiv = document.getElementById('chatHistory');
+            chatDiv.innerHTML = chatHistory.map(msg => `
+                <div class="mb-2">
+                    <strong class="${msg.role === 'user' ? 'text-blue-600' : 'text-green-600'}">
+                        ${msg.role}:
+                    </strong>
+                    <span class="ml-2">${msg.content}</span>
+                </div>
+            `).join('');
+            chatDiv.scrollTop = chatDiv.scrollHeight;
+        }
 
-                // Check for existing item with same description AND length
-                const existingRow = Array.from(table.querySelectorAll('tr')).find(row => {
-                    const existingDesc = row.querySelector('input[name="description"]').value;
-                    const existingLength = parseFloat(row.querySelector('input[name="length"]').value);
-                    return existingDesc === item.description && existingLength === item.length;
-                });
+        function displayFeatures(features) {
+            const output = document.getElementById('featuresOutput');
+            output.innerHTML = features.map(feature => `
+                <div class="mb-4 p-4 bg-white rounded shadow">
+                    <h3 class="font-semibold text-lg mb-2">${feature.feature}</h3>
+                    <p class="text-gray-600">${feature.short_description}</p>
+                </div>
+            `).join('');
+        }
 
-                if (existingRow) {
-                    // Show confirmation modal for duplicate items
-                    const confirmationModal = new bootstrap.Modal(document.getElementById('confirmationModal'));
-                    document.querySelector('#confirmationModal .modal-body').innerHTML = `
-                        <p>Un article avec les mêmes caractéristiques existe déjà :</p>
-                        <p><strong>Description :</strong> ${item.description}</p>
-                        <p><strong>Longueur :</strong> ${item.length.toFixed(2)}</p>
-                        <p>Voulez-vous remplacer l'existant ou annuler ?</p>
-                    `;
-                    
-                    // Handle replace action
-                    document.getElementById('replaceItem').onclick = () => {
-                        existingRow.remove();
-                        insertNewRow(item, table);
-                        confirmationModal.hide();
-                    };
+        // Handle Enter key in chat input
+        document.getElementById('chatInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                sendMessage();
+            }
+        });
 
-                    confirmationModal.show();
-                } else {
-                    // If no duplicate, add the new row
-                    insertNewRow(item, table);
-                }
+        async function generatePlan() {
+            const projectTitle = document.getElementById('projectTitle').value.trim();
+            const requirements = document.getElementById('planRequirements').value.trim();
+            const features = document.getElementById('planFeatures').value.split(',').map(f => f.trim()).filter(f => f);
+            const platform = document.getElementById('platform').value;
+            const additionalRequirements = document.getElementById('additionalRequirements').value.trim();
 
-                updateGrandTotal();
+            if (!projectTitle || !requirements || features.length === 0) {
+                alert('Please fill in all required fields');
+                return;
             }
 
-            // Modify the sort function to handle both type and length
-            function sortItemsByDescriptionAndLength(items) {
-                return items.sort((a, b) => {
-                    // Helper function to extract numbers from description
-                    const getNumber = (desc) => {
-                        const match = desc.match(/\d+/);
-                        return match ? parseInt(match[0]) : 0;
-                    };
-                    
-                    // Helper function to get the type (SISMIQUE or not)
-                    const getType = (desc) => {
-                        return desc.includes('SISMIQUE') ? 1 : 0;
-                    };
-
-                    // Helper function to check if item ends with N
-                    const endsWithN = (desc) => {
-                        return desc.trim().endsWith('N') ? 0 : 1; // 0 for N (to sort first), 1 for others
-                    };
-                    
-                    const numA = getNumber(a.description);
-                    const numB = getNumber(b.description);
-                    const typeA = getType(a.description);
-                    const typeB = getType(b.description);
-                    const nEndingA = endsWithN(a.description);
-                    const nEndingB = endsWithN(b.description);
-                    
-                    // First sort by N ending
-                    if (nEndingA !== nEndingB) {
-                        return nEndingA - nEndingB;
-                    }
+            const loading = document.getElementById('planLoading');
+            const output = document.getElementById('planOutput');
+            loading.style.display = 'block';
+            output.classList.add('hidden');
 
-                    // Then sort by description number
-                    if (numA !== numB) {
-                        return numA - numB;
-                    }
-                    
-                    // Then sort by type (non-SISMIQUE first)
-                    if (typeA !== typeB) {
-                        return typeA - typeB;
-                    }
-                    
-                    // Finally sort by length
-                    return a.length - b.length;
+            try {
+                console.log('Sending request with data:', {
+                    project_title: projectTitle,
+                    requirements,
+                    features,
+                    platform,
+                    additional_requirements: additionalRequirements
                 });
-            }
 
-            function insertNewRow(item, table) {
-                // Get all existing rows as array of items
-                const existingItems = Array.from(table.querySelectorAll('tr')).map(row => ({
-                    description: row.querySelector('input[name="description"]').value,
-                    unit: row.querySelector('input[name="unit"]').value,
-                    quantity: parseInt(row.querySelector('input[name="quantity"]').value, 10),
-                    length: parseFloat(row.querySelector('input[name="length"]').value),
-                    unit_price: parseFloat(row.querySelector('input[name="unitPrice"]').value),
-                    total_price: parseFloat(row.querySelector('input[name="totalHT"]').value)
-                }));
-                
-                // Add new item to array
-                existingItems.push(item);
-                
-                // Sort all items
-                const sortedItems = sortItemsByDescriptionAndLength(existingItems);
-                
-                // Clear table
-                table.innerHTML = '';
-                
-                // Insert all items in sorted order
-                sortedItems.forEach(sortedItem => {
-                    const row = document.createElement('tr');
-                    const isPoutrelles = sortedItem.description.includes('PCP');
-                    
-                    let lengthAttrs;
-                    if (isPoutrelles) {
-                        lengthAttrs = 'step="0.05" type="number" min="0" oninput="adjustToNearestStep(this, 0.05)"';
-                    } else {
-                        lengthAttrs = 'step="1" type="number" min="0" onkeydown="return event.keyCode !== 190" oninput="this.value=Math.floor(this.value)"';
-                    }
-                    
-                    const total = ((sortedItem.quantity || 0) * (sortedItem.length || 0) * (sortedItem.unit_price || 0)).toFixed(2);
-                    
-                    row.innerHTML = `
-                        <td>
-                            <input type="text" class="form-control" name="description" value="${sortedItem.description || ''}" readonly>
-                        </td>
-                        <td>
-                            <input type="text" class="form-control" name="unit" value="${sortedItem.unit || ''}" readonly>
-                        </td>
-                        <td>
-                            <input step="1" type="number" min="0" class="form-control" name="quantity" 
-                                value="${sortedItem.quantity || 0}" 
-                                onkeydown="return event.keyCode !== 190 && event.keyCode !== 188" 
-                                oninput="this.value=Math.floor(this.value)" 
-                                onchange="updateTotal(this)">
-                        </td>
-                        <td>
-                            <input ${lengthAttrs} class="form-control" name="length" 
-                                value="${sortedItem.length || 0}" 
-                                onchange="updateTotal(this)">
-                        </td>
-                        <td>
-                            <input type="number" class="form-control" name="unitPrice" 
-                                value="${sortedItem.unit_price || 0}" 
-                                step="0.01" min="0" 
-                                onchange="updateTotal(this)">
-                        </td>
-                        <td>
-                            <input type="number" class="form-control" name="totalHT" value="${total}" readonly>
-                        </td>
-                        <td>
-                            <button type="button" class="btn btn-danger btn-sm" onclick="this.closest('tr').remove(); updateGrandTotal();">
-                                <i class="fas fa-trash"></i>
-                            </button>
-                        </td>
-                    `;
-                    
-                    table.appendChild(row);
+                const response = await fetch('/generate-plan', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        project_title: projectTitle,
+                        requirements,
+                        features,
+                        platform,
+                        additional_requirements: additionalRequirements
+                    })
                 });
-                
-                updateGrandTotal();
-            }
 
-            // Function to update totals
-            function updateTotals() {
-                const totalHT = Array.from(document.querySelectorAll('input[name="totalHT"]'))
-                    .reduce((sum, input) => sum + (parseFloat(input.value) || 0), 0);
+                const data = await response.json();
+                console.log('Raw API Response:', data);
+                console.log('Sections:', data.sections);
+                console.log('Raw Content:', data.raw_content);
                 
-                const formattedTotalHT = totalHT.toFixed(2);
-                const tvaEnabled = document.querySelector("#tvaSwitch").checked;
-                
-                const tax = tvaEnabled ? (totalHT * 0.20).toFixed(2) : "0.00";
-                const totalTTC = tvaEnabled ? (totalHT * 1.20).toFixed(2) : "0.00";
-                
-                document.querySelector("#totalHT").value = formattedTotalHT;
-                document.querySelector("#tax").value = tax;
-                document.querySelector("#totalTTC").value = totalTTC;
+                displayPlan(data);
+            } catch (error) {
+                console.error('Error generating plan:', error);
+                alert('Error generating plan');
+            } finally {
+                loading.style.display = 'none';
             }
+        }
 
-            // Add event listener for TVA switch
-            document.querySelector("#tvaSwitch").addEventListener('change', updateTotals);
-
-            // Remove the automatic initialization of tables with default items
-            // Comment out or remove these lines:
-            /*
-            defaultItems.poutrelles.forEach(item => addItemRow(item, poutrellesTable));
-            defaultItems.hourdis.forEach(item => addItemRow(item, hourdisTable));
-            defaultItems.panneaux.forEach(item => addItemRow(item, panneauTable));
-            */
-
-            // Predefined items data - Reset all default values to zero
-            const predefinedItems = {
-                poutrelles: [
-                { description: "PCP 113N", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 114N", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 113B SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 114B SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 135 SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 156 SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 157 SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 158 SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PCP 158B SISMIQUE", unit: "ML", quantity: 0, length: 0, unit_price: 0 }
-                ],
-                hourdis: [
-                    { description: "HOURDIS TYPE 08", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "HOURDIS TYPE 12", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "HOURDIS TYPE 16", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "HOURDIS TYPE 20", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "HOURDIS TYPE 25", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "HOURDIS TYPE 30", unit: "U", quantity: 0, length: 0, unit_price: 0 }
-                ],
-                panneaux: [
-                    { description: "PTS Normal 3,5*3,5", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "PTS SISMIQUE 5,0*3,5", unit: "U", quantity: 0, length: 0, unit_price: 0 }
-                ],
-                agglos: [
-                    { description: "AGGLOS TYPE 07", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "AGGLOS TYPE 10", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "AGGLOS TYPE 15", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "AGGLOS TYPE 20", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "AGGLOS TYPE 25", unit: "U", quantity: 0, length: 0, unit_price: 0 },
-                    { description: "AGGLOS A BRANCHER 20", unit: "U", quantity: 0, length: 0, unit_price: 0 }
-                ]
-            };
+        function displayPlan(data) {
+            console.log('Displaying plan data:', data);
+            const output = document.getElementById('planOutput');
+            const title = document.getElementById('planTitle');
+            const sections = document.getElementById('planSections');
 
-            // Function to populate modal with items
-            function populateModal(modalId, items, targetTable) {
-                const modal = document.querySelector(modalId);
-                const tbody = modal.querySelector('tbody');
-                tbody.innerHTML = '';
+            title.textContent = `Technical Project Plan: ${data.project_title}`;
+            console.log('Set title to:', title.textContent);
+            
+            // Clear previous sections
+            sections.innerHTML = '';
 
-                const sortedItems = sortItemsByDescriptionAndLength([...items]);
+            // Display each section
+            Object.entries(data.sections).forEach(([key, content]) => {
+                console.log(`Processing section ${key}:`, content);
                 
-                sortedItems.forEach((item, index) => {
-                    const row = document.createElement('tr');
-                    const isPoutrelles = item.description.includes('PCP');
-                    const baseTabIndex = (index + 1) * 10; // Create unique tabindex groups for each row
-                    
-                    row.innerHTML = `
-                        <td>${item.description}</td>
-                        <td>${item.unit}</td>
-                        <td>
-                            <input type="number" 
-                                class="form-control form-control-sm" 
-                                value="" 
-                                name="modal-quantity" 
-                                min="0"
-                                step="1"
-                                placeholder="Quantité"
-                                tabindex="${baseTabIndex}"
-                                onkeydown="if(event.key === 'Enter') { event.preventDefault(); this.closest('tr').querySelector('[name=modal-length]').focus(); }">
-                            <div class="invalid-feedback">Veuillez entrer une quantité valide.</div>
-                        </td>
-                        <td>
-                            <input type="text" 
-                                class="form-control form-control-sm" 
-                                value="" 
-                                name="modal-length"
-                                placeholder="Longueur"
-                                tabindex="${baseTabIndex + 1}"
-                                onkeydown="if(event.key === 'Enter') { event.preventDefault(); this.closest('tr').querySelector('[name=modal-price]').focus(); }"
-                                oninput="this.value = this.value.replace(',', '.');">
-                            <div class="invalid-feedback">Veuillez entrer une longueur valide.</div>
-                        </td>
-                        <td>
-                            <input type="text" 
-                                class="form-control form-control-sm" 
-                                value="" 
-                                name="modal-price"
-                                placeholder="Prix Unitaire"
-                                tabindex="${baseTabIndex + 2}"
-                                onkeydown="if(event.key === 'Enter') { event.preventDefault(); this.closest('tr').querySelector('.add-item').click(); }"
-                                oninput="this.value = this.value.replace(',', '.');">
-                            <div class="invalid-feedback">Veuillez entrer un prix unitaire valide.</div>
-                        </td>
-                        <td>
-                            <button class="btn btn-primary btn-sm add-item" tabindex="${baseTabIndex + 3}">
-                                Ajouter
-                            </button>
-                        </td>
-                    `;
-
-                    // Add click handler for the add button
-                    row.querySelector('.add-item').addEventListener('click', () => {
-                        const quantityInput = row.querySelector('[name="modal-quantity"]');
-                        const lengthInput = row.querySelector('[name="modal-length"]');
-                        const unitPriceInput = row.querySelector('[name="modal-price"]');
-
-                        const quantity = parseInt(quantityInput.value) || 0;
-                        const length = parseFloat(lengthInput.value.replace(',', '.')) || 0;
-                        const unitPrice = parseFloat(unitPriceInput.value.replace(',', '.')) || 0;
-
-                        let isValid = true;
-
-                        if (quantity === 0) {
-                            quantityInput.classList.add('is-invalid');
-                            isValid = false;
-                        } else {
-                            quantityInput.classList.remove('is-invalid');
-                        }
-
-                        if (length === 0) {
-                            lengthInput.classList.add('is-invalid');
-                            isValid = false;
-                        } else {
-                            lengthInput.classList.remove('is-invalid');
-                        }
-
-                        if (unitPrice === 0) {
-                            unitPriceInput.classList.add('is-invalid');
-                            isValid = false;
-                        } else {
-                            unitPriceInput.classList.remove('is-invalid');
-                        }
-
-                        if (!isValid) {
-                            return;
-                        }
-
-                        const newItem = {
-                            ...item,
-                            quantity: quantity,
-                            length: length,
-                            unit_price: unitPrice
-                        };
-                        addItemRow(newItem, targetTable);
-                        // The modal will remain open, allowing the user to add more items
-                    });
-
-                    tbody.appendChild(row);
-                });
-            }
-
-            // Update button click handlers
-            document.querySelector("#addPoutrelles").addEventListener("click", () => {
-                populateModal('#poutrellesModal', predefinedItems.poutrelles, poutrellesTable);
-                new bootstrap.Modal('#poutrellesModal').show();
-            });
-
-            document.querySelector("#addHourdis").addEventListener("click", () => {
-                populateModal('#hourdisModal', predefinedItems.hourdis, hourdisTable);
-                new bootstrap.Modal('#hourdisModal').show();
-            });
-
-            document.querySelector("#addPanneau").addEventListener("click", () => {
-                populateModal('#panneauModal', predefinedItems.panneaux, panneauTable);
-                new bootstrap.Modal('#panneauModal').show();
-            });
-
-            document.querySelector("#addAgglos").addEventListener("click", () => {
-                populateModal('#agglosModal', predefinedItems.agglos, agglosTable);
-                new bootstrap.Modal('#agglosModal').show();
-            });
-
-            // Form submission
-            invoiceForm.addEventListener("submit", async (event) => {
-                event.preventDefault();
-
-                const urlParams = new URLSearchParams(window.location.search);
-                const editId = urlParams.get('edit');
-
-                const getAllItems = () => {
-                    const items = [];
-                    [poutrellesTable, hourdisTable, panneauTable, agglosTable].forEach(table => {
-                        items.push(...Array.from(table.querySelectorAll("tr")).map(row => ({
-                            description: row.querySelector("input[name='description']").value,
-                            unit: row.querySelector("input[name='unit']").value,
-                            quantity: parseInt(row.querySelector("input[name='quantity']").value, 10),
-                            length: parseFloat(row.querySelector("input[name='length']").value),
-                            unit_price: parseFloat(row.querySelector("input[name='unitPrice']").value),
-                            total_price: parseFloat(row.querySelector("input[name='totalHT']").value)
-                        })));
-                    });
-                    return items;
-                };
-
-                const data = {
-                    invoice_number: document.querySelector("#invoiceNumber").value,
-                    date: new Date(document.querySelector("#date").value).toISOString(),
-                    project: document.querySelector("#project").value,
-                    client_name: document.querySelector("#clientName").value,
-                    phone1: document.querySelector("#clientPhone").value,
-                    phone2: document.querySelector("#clientPhone2").value || null,
-                    address: document.querySelector("#clientAddress").value,
-                    total_ht: parseFloat(document.querySelector("#totalHT").value || 0),
-                    tax: parseFloat(document.querySelector("#tax").value || 0),
-                    total_ttc: parseFloat(document.querySelector("#totalTTC").value || 0),
-                    items: getAllItems(),
-                    frame_number: document.querySelector("#plancher").value || "PH RDC",
-                    status: "pending",
-                    created_at: new Date().toISOString(),
-                    commercial: document.querySelector("#commercial").value || "divers"
-                };
-
-                console.log("Sending invoice data:", data);
-
-                try {
-                    // Determine if we're creating or updating
-                    const url = editId ? `/api/invoices/${editId}` : "/api/invoices/";
-                    const method = editId ? "PUT" : "POST";
-
-                    const response = await fetch(url, {
-                        method: method,
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify(data)
-                    });
-
-                    if (!response.ok) {
-                        const errorData = await response.json();
-                        console.error("Server error:", errorData);
-                        throw new Error(`Failed to ${editId ? 'update' : 'create'} invoice: ${JSON.stringify(errorData)}`);
-                    }
-
-                    const invoice = await response.json();
-                    console.log(editId ? "Updated invoice:" : "Created invoice:", invoice);
-
-                    // Generate PDF
-                    const pdfResponse = await fetch(`/api/invoices/${invoice.id}/generate-pdf`, {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify(invoice)
-                    });
-
-                    if (!pdfResponse.ok) {
-                        const errorData = await pdfResponse.text();
-                        console.error("PDF generation error:", errorData);
-                        throw new Error(`Failed to generate PDF: ${errorData}`);
-                    }
-
-                    // Handle PDF download
-                    const blob = await pdfResponse.blob();
-                    const downloadUrl = window.URL.createObjectURL(blob);
-                    const a = document.createElement("a");
-                    a.href = downloadUrl;
-                    a.download = `devis_${invoice.invoice_number}.pdf`;
-                    document.body.appendChild(a);
-                    a.click();
-                    document.body.removeChild(a);
-                    window.URL.revokeObjectURL(downloadUrl);
-
-                    // Update status to success after PDF generation
-                    try {
-                        const updateStatusResponse = await fetch(`/api/invoices/${invoice.id}/status`, {
-                            method: "PUT",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ status: "completed" })
-                        });
-
-                        if (!updateStatusResponse.ok) {
-                            console.error("Failed to update status:", await updateStatusResponse.text());
-                        } else {
-                            console.log("Status updated successfully");
-                        }
-                    } catch (error) {
-                        console.error("Error updating status:", error);
-                    }
-
-                    // Redirect to history page after successful update
-                    if (editId) {
-                        window.location.href = '/history';
-                    }
-
-                } catch (error) {
-                    console.error("Error:", error);
-                    alert(`Error: ${error.message}`);
-                }
-            });
-
-            // Set today's date automatically
-            const today = new Date();
-            const formattedDate = today.toISOString().split('T')[0];
-            document.querySelector("#date").value = formattedDate;
-
-            // Function to get and update the invoice number
-            async function updateInvoiceNumber(selectedType) {
-                try {
-                    // Disable the input while fetching
-                    invoiceNumberInput.disabled = true;
-                    
-                    const response = await fetch(`/api/invoices/last-number/${selectedType}`);
-                    
-                    if (response.ok) {
-                        const data = await response.json();
-                        invoiceNumberInput.value = data.formatted_number;
-                    } else {
-                        throw new Error('Failed to get invoice number');
-                    }
-                } catch (error) {
-                    console.error('Error:', error);
-                    alert('Error getting invoice number');
-                } finally {
-                    // Re-enable the input
-                    invoiceNumberInput.disabled = false;
+                const sectionTitle = key
+                    .split('_')
+                    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                    .join(' ');
+
+                // Format the content based on type
+                let formattedContent = content;
+                if (typeof content === 'object') {
+                    console.log(`Section ${key} is an object:`, content);
+                    formattedContent = Object.entries(content)
+                        .map(([k, v]) => `<strong>${k}:</strong> ${v}`)
+                        .join('<br>');
                 }
-            }
-
-            // Update invoice number when client type is selected
-            document.querySelectorAll('input[name="clientType"]').forEach(input => {
-                input.addEventListener('change', () => {
-                    updateInvoiceNumber(input.value);
-                });
-            });
-
-            // Update the number when the page loads if a type is already selected
-            const selectedType = document.querySelector('input[name="clientType"]:checked')?.value;
-            if (selectedType) {
-                updateInvoiceNumber(selectedType);
-            }
-
-            // Replace the Excel generation handler with this updated version
-            document.getElementById('generateExcel').addEventListener('click', async () => {
-                try {
-                    console.log('Starting Excel generation process...');
-                    
-                    // Get all form data
-                    const getAllItems = () => {
-                        const items = [];
-                        [poutrellesTable, hourdisTable, panneauTable, agglosTable].forEach(table => {
-                            const tableItems = Array.from(table.querySelectorAll("tr")).map(row => ({
-                                description: row.querySelector("input[name='description']").value,
-                                unit: row.querySelector("input[name='unit']").value,
-                                quantity: parseInt(row.querySelector("input[name='quantity']").value, 10),
-                                length: parseFloat(row.querySelector("input[name='length']").value),
-                                unit_price: parseFloat(row.querySelector("input[name='unitPrice']").value),
-                                total_price: parseFloat(row.querySelector("input[name='totalHT']").value)
-                            }));
-                            console.log(`Found ${tableItems.length} items in ${table.id}`);
-                            items.push(...tableItems);
-                        });
-                        return items;
-                    };
-
-                    const data = {
-                        invoice_number: document.querySelector("#invoiceNumber").value,
-                        date: new Date(document.querySelector("#date").value).toISOString(),
-                        project: document.querySelector("#project").value,
-                        client_name: document.querySelector("#clientName").value,
-                        phone1: document.querySelector("#clientPhone").value,
-                        phone2: document.querySelector("#clientPhone2").value || null,
-                        address: document.querySelector("#clientAddress").value,
-                        total_ht: parseFloat(document.querySelector("#totalHT").value || 0),
-                        tax: parseFloat(document.querySelector("#tax").value || 0),
-                        total_ttc: parseFloat(document.querySelector("#totalTTC").value || 0),
-                        items: getAllItems(),
-                        frame_number: document.querySelector("#plancher").value || "PH RDC",
-                        status: "pending",
-                        created_at: new Date().toISOString(),
-                        commercial: document.querySelector("#commercial").value || "divers"
-                    };
 
-                    console.log('Form data collected:', {
-                        invoice_number: data.invoice_number,
-                        client_name: data.client_name,
-                        items_count: data.items.length,
-                        total_ttc: data.total_ttc
-                    });
-
-                    // First create the invoice if it doesn't exist
-                    console.log('Creating invoice...');
-                    const createResponse = await fetch("/api/invoices/", {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify(data)
-                    });
-
-                    if (!createResponse.ok) {
-                        throw new Error('Failed to create invoice');
-                    }
-
-                    const invoice = await createResponse.json();
-                    console.log("Created invoice:", invoice.id);
-
-                    // Then generate the Excel file
-                    console.log('Generating Excel file...');
-                    const response = await fetch(`/api/invoices/${invoice.id}/generate-excel`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify(invoice)
-                    });
-
-                    if (!response.ok) {
-                        throw new Error('Failed to generate Excel file');
-                    }
-
-                    console.log('Excel file generated successfully');
-
-                    // Handle file download
-                    const blob = await response.blob();
-                    const url = window.URL.createObjectURL(blob);
-                    const a = document.createElement('a');
-                    a.href = url;
-                    a.download = `devis_${invoice.invoice_number}.xlsx`;
-                    document.body.appendChild(a);
-                    a.click();
-                    document.body.removeChild(a);
-                    window.URL.revokeObjectURL(url);
-                    console.log('Excel file downloaded');
-
-                    // Update invoice number after successful generation
-                    const selectedType = document.querySelector('input[name="clientType"]:checked')?.value;
-                    if (selectedType) {
-                        console.log('Updating invoice number...');
-                        await updateInvoiceNumber(selectedType);
-                    }
-
-                    console.log('Excel generation process completed successfully');
-
-                } catch (error) {
-                    console.error('Error in Excel generation:', error);
-                    alert('Error generating Excel file: ' + error.message);
-                }
+                const section = document.createElement('div');
+                section.className = 'mb-6 bg-white p-4 rounded shadow';
+                section.innerHTML = `
+                    <h4 class="text-lg font-semibold mb-3 text-blue-600">${sectionTitle}</h4>
+                    <div class="whitespace-pre-wrap text-gray-700 prose max-w-none">
+                        ${formattedContent}
+                    </div>
+                `;
+                sections.appendChild(section);
             });
 
-            // Check for edit mode
-            const urlParams = new URLSearchParams(window.location.search);
-            const editId = urlParams.get('edit');
-
-            if (editId) {
-                console.log('Loading invoice for editing, ID:', editId);
-                fetch(`/api/invoices/${editId}`)
-                    .then(response => response.json())
-                    .then(invoice => {
-                        console.log('Loaded invoice data:', invoice);
-                        
-                        // Populate form fields
-                        document.querySelector("#clientName").value = invoice.client_name;
-                        document.querySelector("#clientPhone").value = invoice.phone1;
-                        document.querySelector("#clientPhone2").value = invoice.phone2;
-                        document.querySelector("#clientAddress").value = invoice.address;
-                        document.querySelector("#plancher").value = invoice.frame_number || 'PH RDC';
-                        document.querySelector("#invoiceNumber").value = invoice.invoice_number;
-                        document.querySelector("#date").value = invoice.date.split('T')[0];
-
-                        // Clear existing tables first
-                        console.log('Clearing existing tables');
-                        [poutrellesTable, hourdisTable, panneauTable, agglosTable].forEach(table => {
-                            table.innerHTML = '';
-                        });
-
-                        // Populate items
-                        console.log('Populating items:', invoice.items);
-                        invoice.items.forEach(item => {
-                            console.log('Processing item:', item);
-                            if (item.description.includes('PCP')) {
-                                console.log('Adding to poutrelles table');
-                                addItemRow(item, poutrellesTable);
-                            } else if (item.description.includes('HOURDIS')) {
-                                console.log('Adding to hourdis table');
-                                addItemRow(item, hourdisTable);
-                            } else if (item.description.includes('PTS')) {
-                                console.log('Adding to panneau table');
-                                addItemRow(item, panneauTable);
-                            } else {
-                                console.log('Adding to agglos table');
-                                addItemRow(item, agglosTable);
-                            }
-                        });
-                    })
-                    .catch(error => {
-                        console.error("Error loading invoice:", error);
-                        alert("Error loading invoice data");
-                    });
-            }
-
-            // Update current date in header
-            document.getElementById('currentDate').textContent = new Date().toLocaleDateString('fr-FR');
-        });
+            console.log('Final HTML output:', sections.innerHTML);
+            output.classList.remove('hidden');
+        }
     </script>
 </body>
 </html>

migrations/versions/xxxx_add_invoice_sequence.py

@@ -1,28 +0,0 @@
-"""add invoice sequence and client type
-
-Revision ID: xxxx
-Revises: previous_revision_id
-Create Date: 2024-xx-xx
-"""
-from alembic import op
-import sqlalchemy as sa
-
-def upgrade():
-    # Create sequence for invoice IDs
-    op.execute('CREATE SEQUENCE IF NOT EXISTS invoice_id_seq START 1')
-    
-    # Add client_type column if not exists
-    op.add_column('invoices', sa.Column('client_type', sa.String(10), nullable=True))
-    
-    # Make invoice_number unique
-    op.create_unique_constraint('uq_invoice_number', 'invoices', ['invoice_number'])
-
-def downgrade():
-    # Remove unique constraint
-    op.drop_constraint('uq_invoice_number', 'invoices')
-    
-    # Drop client_type column
-    op.drop_column('invoices', 'client_type')
-    
-    # Drop sequence
-    op.execute('DROP SEQUENCE IF EXISTS invoice_id_seq') 

re.md

@@ -0,0 +1,27 @@
+# Flan-T5 Testing Architecture
+
+## Project Structure
+```
+flan-t5-testing/
+├── backend/
+│   ├── app/
+│   │   ├── main.py           # FastAPI application entry point
+│   │   ├── controllers/
+│   │   │   └── scraper_controller.py
+│   │   ├── services/
+│   │   │   ├── scraper_service.py
+│   │   │   └── flan_t5_service.py
+│   │   └── models/
+│   │       └── scrape_log.py
+│   ├── utils/
+│   │   ├── text_extractor.py
+│   │   └── html_cleaner.py
+│   └── requirements.txt
+└── frontend/
+    ├── src/
+    │   ├── components/
+    │   │   ├── ScrapingForm.jsx
+    │   │   └── ResultDisplay.jsx
+    │   ├── App.jsx
+    │   └── main.jsx
+    └── package.json