Update app.py

app.py

@@ -8,7 +8,7 @@ import textwrap
 API_KEY = st.secrets["GOOGLE_API_KEY"]
 
 # Page configuration
-st.set_page_config(page_title="🔄✨ Gemini2 Script Mig Gen Pro", page_icon="🔄✨", layout="wide")
+st.set_page_config(page_title="🚀✨ Gemini2 CI/CD Gen Pro", page_icon="🚀✨", layout="wide")
 
 # --- Helper Functions ---
 def send_message_to_model(message, model_name, temperature, top_p, top_k, max_tokens):
@@ -33,64 +33,100 @@ def send_message_to_model(message, model_name, temperature, top_p, top_k, max_to
         st.error(f"❌ Error communicating with the AI: {e}")
         return None
 
-def generate_migration_script(prompt_base, model_name, temperature, top_p, top_k, max_tokens, source_type, target_type, custom_requirements, specific_details, transformation_details):
-    """Generates a migration script based on user settings."""
+def generate_cicd_pipeline(prompt_base, model_name, temperature, top_p, top_k, max_tokens, target_systems, custom_requirements, specific_details, deploy_details, docker_details, kubernetes_details, test_details):
+    """Generates a CI/CD pipeline based on user settings."""
     prompt = f"""
-        You are an expert automation engineer specializing in migration scripts. Your task is to generate a complete, secure, and efficient migration script based on the following description:
+        You are an expert DevOps engineer specializing in CI/CD pipelines. Your task is to generate complete, secure, and efficient CI/CD pipeline configurations based on the following description:
 
-        **Goal:** Create the most complete, detailed, and efficient migration script possible, considering all variables, edge cases, and potential scenarios.
+        **Goal:** Create the most complete, detailed, and efficient CI/CD pipeline possible, considering all variables, edge cases, and potential scenarios.
 
-        **Migration Description:** {prompt_base}
-
-        **Source Type:** {source_type if source_type else "None"}
-        **Target Type:** {target_type if target_type else "None"}
-        **Transformation Details:** {transformation_details if transformation_details else "None"}
+        **Pipeline Description:** {prompt_base}
+        
+         **Target Systems:** {target_systems if target_systems else "None"}
+        **Deployment Details:** {deploy_details if deploy_details else "None"}
+        **Docker Details:** {docker_details if docker_details else "None"}
+         **Kubernetes Details:** {kubernetes_details if kubernetes_details else "None"}
+        **Test Details:** {test_details if test_details else "None"}
         **Custom Requirements:** {custom_requirements if custom_requirements else "None"}
         **Specific Details:** {specific_details if specific_details else "None"}
 
         **Response Format:**
-        - Respond in Markdown format, including a python code block with its original formatting, without line breaks.
-        - The python code block must be delimited by ```python and ```.
+        - Respond in Markdown format, including YAML code blocks for Argo CD, GitHub Actions, GitLab Runner, Jenkins, CircleCI, and a Docker Compose, with their original formatting and without line breaks.
+         - The Argo CD code block must be delimited by ```yaml argocd and ```.
+        - The GitHub Actions code block must be delimited by ```yaml githubactions and ```.
+        - The GitLab Runner code block must be delimited by ```yaml gitlabrunner and ```.
+        - The Jenkins code block must be delimited by ```yaml jenkins and ```.
+         - The CircleCI code block must be delimited by ```yaml circleci and ```.
+         - The Docker Compose code block must be delimited by ```yaml dockercompose and ```.
         - Do not include comments, explanations, or any other text outside the code block, unless the prompt requires.
         - The code must maintain its full vertical formatting, respecting indentation and line breaks.
         - The code must be realistic, using real-world examples, data, and situations.
         - Explore different approaches, techniques, and advanced practices, always prioritizing security and efficiency.
-         - The code must use best practices for accessing resources, connecting to databases, handling errors and logging data.
-        - Unless the user specifies otherwise, use the most current and secure versions of libraries and resources, using python and following best practices.
-         - The code must use a valid logging system with timestamps and log levels.
-        - The code must be well structured according to PEP8 guidelines, with docstrings and clear naming conventions.
-        - Use incremental reasoning to add improvements, expansions, and considerations to your code.
+        - Use best practices for building images, running tests, and deploying applications.
+        - Unless the user specifies otherwise, use the most current and secure versions of the tools and resources, using YAML and following best practices.
+         - Use incremental reasoning to add improvements, expansions, and considerations to your code.
         - Use the history of the conversations so that the response is incremental.
-         - If the user requests for a transformation, generate it using python code and libraries, and document every step in the code.
+        - If Docker is required, generate configurations to build Docker Images and push to Dockerhub.
+        - If kubernetes is required, use Argo CD for deployments and create the necessary configurations, generating the application.yaml, and any other resources.
+         - If any connection parameters are needed, use placeholders in the code with comments like 'PLEASE FILL THIS' indicating where the user should fill in.
+        - Use comments to explain the configurations.
+        - If the user does not specify target systems, generate for Argo CD, Github Actions and Gitlab Runner.
 
         **Important:**
-        - Generate only one script at a time.
+        - Generate only one pipeline at a time.
         - Create the longest, most complete, and detailed code possible to cover a wide range of possibilities and scenarios.
-        - Consider all the details of the request, expanding the response and improving the script.
-         - If the user does not provide details on connection parameters, create placeholders in the code with comments like 'PLEASE FILL THIS' indicating where the user should fill in.
-        - If the user does not provide the details about source and target, use MySQL as source and SQLite as target, and include comments on what the user should change, use the comments '# SOURCE DATABASE' and '# TARGET DATABASE'.
-         - Provide in your code all necessary comments for the user to understand the process of migration and where he should add his parameters.
-        - Use `try/except` blocks for error handling, and document what could cause the errors.
+         - Consider all the details of the request, expanding the response and improving the code.
         """
     response = send_message_to_model(prompt, model_name, temperature, top_p, top_k, max_tokens)
     return response
 
-def parse_and_save_py(ai_code, short_title):
-    """Parses the markdown and saves the python code as .py."""
-    match = re.search(r'```python\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
-    if match:
-        py_code = match.group(1).strip()
-    else:
-        py_code = ai_code.strip()
+def parse_and_save_yaml(ai_code, short_title):
+    """Parses the markdown and saves the YAML code."""
+    argocd_match = re.search(r'```yaml argocd\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    github_actions_match = re.search(r'```yaml githubactions\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    gitlab_runner_match = re.search(r'```yaml gitlabrunner\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    jenkins_match = re.search(r'```yaml jenkins\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    circleci_match = re.search(r'```yaml circleci\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    dockercompose_match = re.search(r'```yaml dockercompose\s*(.*?)\s*```', ai_code, re.DOTALL | re.IGNORECASE)
+    
+    argocd_code = argocd_match.group(1).strip() if argocd_match else None
+    github_actions_code = github_actions_match.group(1).strip() if github_actions_match else None
+    gitlab_runner_code = gitlab_runner_match.group(1).strip() if gitlab_runner_match else None
+    jenkins_code = jenkins_match.group(1).strip() if jenkins_match else None
+    circleci_code = circleci_match.group(1).strip() if circleci_match else None
+    dockercompose_code = dockercompose_match.group(1).strip() if dockercompose_match else None
+
+    base_file_name = f"cicd_pipeline_{short_title}"
+
+    files = {}
+    
+    if argocd_code:
+       files["argocd"] = {"name":f"{base_file_name}_argocd.yaml", "code":argocd_code}
+    
+    if github_actions_code:
+        files["githubactions"] = {"name":f"{base_file_name}_githubactions.yaml", "code":github_actions_code}
+    
+    if gitlab_runner_code:
+        files["gitlabrunner"] = {"name":f"{base_file_name}_gitlabrunner.yaml", "code":gitlab_runner_code}
+
+    if jenkins_code:
+         files["jenkins"] =  {"name":f"{base_file_name}_jenkins.yaml", "code":jenkins_code}
+    
+    if circleci_code:
+        files["circleci"] = {"name":f"{base_file_name}_circleci.yaml", "code":circleci_code}
+    
+    if dockercompose_code:
+        files["dockercompose"] = {"name":f"{base_file_name}_dockercompose.yaml", "code":dockercompose_code}
 
-    file_name = f"migration_script_{short_title}.py"
-    with open(file_name, "w", encoding="utf-8") as f:
-        f.write(py_code)
-    return file_name, py_code
+    for key, value in files.items():
+        with open(value["name"], "w", encoding="utf-8") as f:
+            f.write(value["code"])
+    
+    return files
 
 def main():
-    st.title("🔄✨ Gemini2 Script Mig Gen Pro by [Elias Andrade](https://github.com/chaos4455)")
-    st.markdown("Generate advanced migration scripts with ease! 🚀")
+    st.title("🚀✨ Gemini2 CI/CD Gen Pro by [Elias Andrade](https://github.com/chaos4455)")
+    st.markdown("Generate advanced CI/CD pipelines with ease! 🚀")
     st.markdown("---")
 
     # Layout in columns (sidebar and main area)
@@ -106,64 +142,68 @@ def main():
             top_k = st.slider("Top K", min_value=1, max_value=100, value=40, step=1, help="Adjust the AI's number of candidate tokens.")
             max_tokens = st.number_input("📏 Max Tokens", min_value=128, max_value=8192, value=8192, step=128, help="Adjust the maximum size of the response.")
         
-        with st.expander("🧰 Migration Settings"):
-             source_type = st.selectbox("📦 Source Type", ["MySQL", "PostgreSQL", "SQLite", "MongoDB", "CSV", "JSON", "Parquet", "Excel", "BigQuery", "Snowflake", "Redis", "Kafka", "Other"], index=0, help="Select the type of the data source.")
-             target_type = st.selectbox("🎯 Target Type", ["SQLite", "MySQL", "PostgreSQL", "MongoDB", "CSV", "JSON", "Parquet", "Excel", "BigQuery", "Snowflake", "Redis", "Kafka", "Other"], index=0, help="Select the type of the data target.")
-             transformation_details = st.text_area("🔄 Transformation Details",  placeholder="Specify any transformations or filtering needed (e.g., convert date formats, filter rows, etc).",
-                                 help="Provide details of any transformations you need during the migration, using Python or SQL, if it can be done with SQL.",
-                                  )
-             custom_requirements = st.text_input("➕ Custom Requirements:", placeholder="Specific libraries or parameters (e.g., version, parameters)", help="List specific libraries and versions, parameters, etc.")
-             specific_details = st.text_input("ℹ️ Specific Details", placeholder="Special options, edge cases", help="Add specific details for the script generation.")
+        with st.expander("🧰 Pipeline Settings"):
+            target_systems = st.multiselect("🎯 Target Systems", ["Argo CD", "GitHub Actions", "GitLab Runner", "Jenkins", "CircleCI", "Docker Compose", "Other"], default=["Argo CD", "GitHub Actions", "GitLab Runner"], help="Select the target systems for the pipeline.")
+            deploy_details = st.text_area("🚀 Deployment Details", placeholder="Specify deployment details, e.g., Kubernetes manifests, Dockerfiles, etc.", help="Provide any details about how and where to deploy")
+            docker_details = st.text_input("🐳 Docker Details", placeholder="Specify details like Docker registry, image names, etc.", help="Provide details about docker builds")
+            kubernetes_details = st.text_input("☸️ Kubernetes Details", placeholder="Specify details like namespaces, deployments, etc.", help="Provide details about kubernetes deployments")
+            test_details = st.text_input("🧪 Test Details", placeholder="Specify test details or test commands", help="Provide any details about the tests to be executed")
+            custom_requirements = st.text_input("➕ Custom Requirements:", placeholder="Specific steps or tools (e.g., terraform, ansible)", help="List any specific steps or tools.")
+            specific_details = st.text_input("ℹ️ Specific Details", placeholder="Special options, edge cases", help="Add specific details for the pipeline generation.")
 
     with col2:
-        # User's base prompt
-        prompt_base = st.text_area("📝 Describe the Migration:", 
+         # User's base prompt
+        prompt_base = st.text_area("📝 Describe the CI/CD Pipeline:", 
                                   placeholder=textwrap.dedent("""
-                                    Describe your migration process in detail.
+                                    Describe your CI/CD pipeline in detail.
                                     Include:
-                                        - Source and target system details (e.g., database IPs, ports, logins, passwords).
-                                        - Specific tables to migrate.
-                                        - Any filtering, transformations, or data cleansing needed.
-                                        - Important notes about the systems (e.g., if there is an external system involved)
-                                    If connection details or source and target are not included, the script will be generated using defaults, and you must fill in the parameters.
+                                        - Steps for building, testing, and deploying your application.
+                                        - Specific tools to be used (e.g., Docker, Kubernetes, Argo CD, etc).
+                                        - DockerHub details (user, password) or any other registry details.
+                                        - Kubernetes cluster details.
+                                        - Any custom parameters, configurations, or secrets you need.
+                                       If those details are not included, the pipeline will be generated using defaults, and you must fill in the parameters.
                                    """), key="prompt_base",
-                                  help="Provide a detailed description of your migration, including source and target systems, tables, transformations, and any specific parameters.")
+                                   help="Provide a detailed description of your CI/CD pipeline.")
 
-        if st.button("✨ Generate Migration Script"):
-            if not prompt_base:
-                st.error("⚠️ Please enter a migration description.")
-                return
+        if st.button("✨ Generate CI/CD Pipeline"):
+             if not prompt_base:
+                 st.error("⚠️ Please enter a pipeline description.")
+                 return
 
-            with st.spinner("⏳ Generating script..."):
-                ai_code = generate_migration_script(
+             with st.spinner("⏳ Generating pipeline..."):
+                ai_code = generate_cicd_pipeline(
                    prompt_base,
                    model_name,
                    temperature,
                    top_p,
                    top_k,
                    max_tokens,
-                   source_type,
-                   target_type,
+                   target_systems,
                    custom_requirements,
                    specific_details,
-                   transformation_details
+                   deploy_details,
+                   docker_details,
+                   kubernetes_details,
+                   test_details
                    )
 
                 if ai_code:
-                    st.markdown("### ✅ Generated Migration Script:")
-                    st.code(ai_code, language="python")
-
-                    short_title = prompt_base[:30].strip().replace(" ", "_").lower()
-                    file_name_py, py_code = parse_and_save_py(ai_code, short_title)
-
-                    st.download_button(
-                        label="⬇️ Download Script (.py)",
-                        data=py_code,
-                        file_name=file_name_py,
-                        mime="application/x-python",
-                    )
+                     st.markdown("### ✅ Generated Pipeline:")
+                     st.code(ai_code, language="text")
+
+                     short_title = prompt_base[:30].strip().replace(" ", "_").lower()
+                     files = parse_and_save_yaml(ai_code, short_title)
+
+                     for key, value in files.items():
+                         st.download_button(
+                             label=f"⬇️ Download Pipeline (.{(key)})",
+                             data=value["code"],
+                             file_name=value["name"],
+                             mime="application/x-yaml",
+                         )
                 else:
-                    st.error("❌ Error generating the script. Check the connection with the AI and try again.")
+                    st.error("❌ Error generating the pipeline. Check the connection with the AI and try again.")
 
 if __name__ == "__main__":
     main()