Upload 10 files

app.py

@@ -1,46 +1,706 @@
-"""
-Graded Challenge 5
-Nama: Devin Yaung Lee
-Batch: HCK-009
-program ini untuk mendeploy model
-"""
-
-import streamlit as st
-import eda
-import model
-
-page = st.sidebar.selectbox(label="Select Page:", options=["Home Page", "Exploratory Data Analysis", "Predict Payment"])
-
-if page == "Home Page":
-    st.title("Home Page")
-    st.write('')
-    st.write("Graded Challenge 5")
-    st.write("Name  : Devin Yaung Lee")
-    st.write("Batch : HCK-009")
-    st.write("Aplikasi ini memiliki tujuan utama dari aplikasi ini adalah untuk menampilkan hasil analisis data eksploratori dan untuk memprediksi apakah klien akan gagal membayar tagihan kartu kredit mereka pada bulan berikutnya berdasarkan data yang diberikan oleh pengguna.")
-    st.write('')
-    st.write('')
-    st.write('')
-
-    with st.expander("Background Information"):
-        st.caption("Data ini membahas tentang pembayaran kartu kredit pelanggan, dimana tujuan utama dari dashboard ini adalah untuk mengetahui apakah pelanggan melunasi atau terlambat untuk melunasi, dimana ketentuan ini akan dilakukan berdasarkan dari pengisian parameter-parameter yang sudah dilakukan.")
-    with st.expander("Conclusion"):
-        st.caption("""
-        - Data ini memiliki sifat data yang imbalanced, hal ini dapat dilihat 
-          dari proses hasil train dan test, sebelum dan sesudah di hyperparameter 
-          tuning. Model SVM memiliki peningkatan namun tidak signifikan.
-        - Berdasarkan visualisasi, pelanggan yang sudah bayar mendominasi. 
-          Edukasi terbanyak adalah Universitas. Gender didominasi oleh wanita, 
-          dan untuk status pernikahan lebih banyak yang single.
-        - Pemilihan model adalah SVM berdasarkan pengujian dari model 
-          Logistic regression, KNN, dan SVM.
-        - Analisa credit behaviour menunjukkan 'Use Revolving Credit' paling umum. 
-          Kebanyakan pelanggan memilih untuk membayar sebagian tagihan mereka 
-          setiap bulan.
-        """)
-
-elif page == "Exploratory Data Analysis":
-    eda.run() # Calls the run function from eda
+# SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+import os
+import sys
+import time
+import calendar
+import json
+from model_setup_manager import download_model_by_name, build_engine_by_name
+import logging
+import gc
+import torch
+from pathlib import Path
+from trt_llama_api import TrtLlmAPI
+from whisper.trt_whisper import WhisperTRTLLM, decode_audio_file
+#from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+#from langchain_community.embeddings import HuggingFaceBgeEmbeddings
+from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+from collections import defaultdict
+from llama_index import ServiceContext
+from llama_index.llms.llama_utils import messages_to_prompt, completion_to_prompt
+from llama_index import set_global_service_context
+from faiss_vector_storage import FaissEmbeddingStorage
+from ui.user_interface import MainInterface
+from scipy.io import wavfile
+import scipy.signal as sps
+import numpy as np
+from pynvml import nvmlInit, nvmlDeviceGetHandleByIndex, nvmlDeviceGetMemoryInfo
+from CLIP import run_model_on_images, CLIPEmbeddingStorageEngine
+from PIL import Image
+from transformers import CLIPProcessor, CLIPModel
+import shutil
+from llm_prompt_templates import LLMPromptTemplate
+from utils import (read_model_name)
+import win32api
+import win32security
 
+selected_CLIP = False
+clip_engine = None
+selected_ChatGLM = False
+app_config_file = 'config\\app_config.json'
+model_config_file = 'config\\config.json'
+preference_config_file = 'config\\preferences.json'
+data_source = 'directory'
+
+# Use GetCurrentProcess to get a handle to the current process
+hproc = win32api.GetCurrentProcess()
+# Use GetCurrentProcessToken to get the token of the current process
+htok = win32security.OpenProcessToken(hproc, win32security.TOKEN_QUERY)
+
+# Retrieve the list of privileges enabled
+privileges = win32security.GetTokenInformation(htok, win32security.TokenPrivileges)
+
+# Iterate over privileges and output the ones that are enabled
+priv_list = []
+for priv_id, priv_flags in privileges:
+    # Check if privilege is enabled
+    if priv_flags == win32security.SE_PRIVILEGE_ENABLED or win32security.SE_PRIVILEGE_ENABLED_BY_DEFAULT:
+        # Lookup the name of the privilege
+        priv_name = win32security.LookupPrivilegeName(None, priv_id)
+        priv_list.append(priv_name)
+
+print(f"Privileges of app process: {priv_list}")
+
+def read_config(file_name):
+    try:
+        with open(file_name, 'r', encoding='utf8') as file:
+            return json.load(file)
+    except FileNotFoundError:
+        print(f"The file {file_name} was not found.")
+    except json.JSONDecodeError:
+        print(f"There was an error decoding the JSON from the file {file_name}.")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+    return None
+
+
+def get_model_config(config, model_name=None):
+        selected_model = next((model for model in config["models"]["supported"] if model["name"] == model_name),
+                              config["models"]["supported"][0])
+        metadata = selected_model["metadata"]
+
+        cwd = os.getcwd()  # Current working directory, to avoid calling os.getcwd() multiple times
+
+        if "ngc_model_name" in selected_model:
+            return {
+                "model_path": os.path.join(cwd, "model", selected_model["id"], "engine") if "id" in selected_model else None,
+                "engine": metadata.get("engine", None),
+                "tokenizer_path": os.path.join(cwd, "model", selected_model["id"] ,selected_model["prerequisite"]["tokenizer_local_dir"] ) if "tokenizer_local_dir" in selected_model["prerequisite"] else None,
+                "vocab": os.path.join(cwd, "model", selected_model["id"] ,selected_model["prerequisite"]["vocab_local_dir"], selected_model["prerequisite"]["tokenizer_files"]["vocab_file"]) if "vocab_local_dir" in selected_model["prerequisite"] else None,
+                "max_new_tokens": metadata.get("max_new_tokens", None),
+                "max_input_token": metadata.get("max_input_token", None),
+                "temperature": metadata.get("temperature", None),
+                "prompt_template": metadata.get("prompt_template", None)
+            }
+        elif "hf_model_name" in selected_model:
+            return {
+                "model_path": os.path.join(cwd, "model", selected_model["id"]) if "id" in selected_model else None,
+                "tokenizer_path": os.path.join(cwd, "model", selected_model["id"]) if "id" in selected_model else None,
+                "prompt_template": metadata.get("prompt_template", None)
+            }
+
+		
+def get_asr_model_config(config, model_name=None):
+    models = config["models"]["supported_asr"]
+    selected_model = next((model for model in models if model["name"] == model_name), models[0])
+    return {
+        "model_path": os.path.join(os.getcwd(), selected_model["metadata"]["model_path"]),
+        "assets_path": os.path.join(os.getcwd(), selected_model["metadata"]["assets_path"])
+    }
+
+def get_data_path(config):
+    return os.path.join(os.getcwd(), config["dataset"]["path"])
+
+# read the app specific config
+app_config = read_config(app_config_file)
+streaming = app_config["streaming"]
+similarity_top_k = app_config["similarity_top_k"]
+is_chat_engine = app_config["is_chat_engine"]
+embedded_model_name = app_config["embedded_model"]
+embedded_model = os.path.join(os.getcwd(), "model", embedded_model_name)
+embedded_dimension = app_config["embedded_dimension"]
+use_py_session = app_config["use_py_session"]
+trtLlm_debug_mode = app_config["trtLlm_debug_mode"]
+add_special_tokens = app_config["add_special_tokens"]
+verbose = app_config["verbose"]
+
+# read model specific config
+selected_model_name = None
+selected_data_directory = None
+config = read_config(model_config_file)
+if os.path.exists(preference_config_file):
+    perf_config = read_config(preference_config_file)
+    selected_model_name = perf_config.get('models', {}).get('selected')
+    selected_data_directory = perf_config.get('dataset', {}).get('path')
+
+if selected_model_name == None:
+    selected_model_name = config["models"].get("selected")
+
+if selected_model_name == "CLIP":
+    selected_CLIP = True
+if selected_model_name == "ChatGLM 3 6B int4 (Supports Chinese)":
+    selected_ChatGLM = True
+
+model_config = get_model_config(config, selected_model_name)
+data_dir = config["dataset"]["path"] if selected_data_directory == None else selected_data_directory
+
+asr_model_name = "Whisper Medium Int8"
+asr_model_config = get_asr_model_config(config, asr_model_name)
+asr_engine_path = asr_model_config["model_path"]
+asr_assets_path = asr_model_config["assets_path"]
+
+whisper_model = None
+whisper_model_loaded = False
+enable_asr = config["models"]["enable_asr"]
+nvmlInit()
+
+def generate_inferance_engine(data, force_rewrite=False):
+    """
+       Initialize and return a FAISS-based inference engine.
+
+       Args:
+           data: The directory where the data for the inference engine is located.
+           force_rewrite (bool): If True, force rewriting the index.
+
+       Returns:
+           The initialized inference engine.
+
+       Raises:
+           RuntimeError: If unable to generate the inference engine.
+       """
+    try:
+        global engine
+        faiss_storage = FaissEmbeddingStorage(data_dir=data,
+                                              dimension=embedded_dimension)
+        faiss_storage.initialize_index(force_rewrite=force_rewrite)
+        engine = faiss_storage.get_engine(is_chat_engine=is_chat_engine, streaming=streaming,
+                                          similarity_top_k=similarity_top_k)
+    except Exception as e:
+        raise RuntimeError(f"Unable to generate the inference engine: {e}")
+
+def generate_clip_engine(data_dir, model_path, clip_model, clip_processor, force_rewrite=False):
+    global clip_engine
+    clip_engine = CLIPEmbeddingStorageEngine(data_dir, model_path, clip_model, clip_processor)
+    clip_engine.create_nodes(force_rewrite)
+    clip_engine.initialize_index(force_rewrite)
+
+llm = None
+embed_model = None
+service_context = None
+clip_model = None
+clip_processor = None
+
+if selected_CLIP:
+# Initialize model and processor
+    clip_model = CLIPModel.from_pretrained(model_config["model_path"]).to('cuda')
+    clip_processor = CLIPProcessor.from_pretrained(model_config["model_path"])
+    generate_clip_engine(data_dir, model_config["model_path"], clip_model, clip_processor)
 else:
-    model.run() # Calls the run function from model
+    # create trt_llm engine object
+    model_name, _ = read_model_name(model_config["model_path"])
+    prompt_template_obj = LLMPromptTemplate()
+    text_qa_template_str = prompt_template_obj.model_context_template(model_name)
+    selected_completion_to_prompt =  text_qa_template_str
+    llm = TrtLlmAPI(
+        model_path=model_config["model_path"],
+        engine_name=model_config["engine"],
+        tokenizer_dir=model_config["tokenizer_path"],
+        temperature=model_config["temperature"],
+        max_new_tokens=model_config["max_new_tokens"],
+        context_window=model_config["max_input_token"],
+        vocab_file=model_config["vocab"],
+        messages_to_prompt=messages_to_prompt,
+        completion_to_prompt=selected_completion_to_prompt,
+        use_py_session=use_py_session,
+        add_special_tokens=add_special_tokens,
+        trtLlm_debug_mode=trtLlm_debug_mode,
+        verbose=verbose
+    )
+
+    # create embeddings model object
+    embed_model = HuggingFaceEmbeddings(model_name=embedded_model)
+    service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model,
+                                                context_window=model_config["max_input_token"], chunk_size=512,
+                                                chunk_overlap=200)
+    set_global_service_context(service_context)
+
+    # load the vectorstore index
+    generate_inferance_engine(data_dir)
+
+def call_llm_streamed(query):
+    partial_response = ""
+    response = llm.stream_complete(query, formatted=False)
+    for token in response:
+        partial_response += token.delta
+        yield partial_response
+
+def chatbot(query, chat_history, session_id):
+    if selected_CLIP:
+        ts = calendar.timegm(time.gmtime())
+        temp_image_folder_name = "Temp/Temp_Images"
+        if os.path.isdir(temp_image_folder_name):                
+            try:
+                shutil.rmtree(os.path.join(os.getcwd(), temp_image_folder_name))
+            except Exception as e:
+                print("Exception during folder delete", e)
+        image_results_path = os.path.join(os.getcwd(), temp_image_folder_name, str(ts))
+        res_im_paths = clip_engine.query(query, image_results_path)
+        if len(res_im_paths) == 0:
+            yield "No supported images found in the selected folder"
+            torch.cuda.empty_cache()
+            gc.collect()
+            return
+
+        div_start = '<div class="chat-output-images">'
+        div_end = '</div>'
+        im_elements = ''
+        for i, im in enumerate(res_im_paths):
+            if i>2 : break # display atmost 3 images.
+            cur_data_link_src = temp_image_folder_name +"/" + str(ts) + "/" + os.path.basename(im)
+            cur_src = "file/" + temp_image_folder_name +"/" + str(ts) + "/" + os.path.basename(im)
+            im_elements += '<img data-link="{data_link_src}" src="{src}"/>'.format(src=cur_src, data_link_src=cur_data_link_src)
+        full_div = (div_start + im_elements + div_end)
+        folder_link = f'<a data-link="{image_results_path}">{"See all matches"}</a>'
+        prefix = ""
+        if(len(res_im_paths)>1): 
+            prefix = "Here are the top matching pictures from your dataset"
+        else:
+            prefix = "Here is the top matching picture from your dataset"
+        response = prefix + "<br>"+ full_div + "<br>"+ folder_link
+
+        gc.collect()
+        torch.cuda.empty_cache()
+        yield response
+        torch.cuda.empty_cache()
+        gc.collect()
+        return
+
+    if data_source == "nodataset":
+        yield llm.complete(query, formatted=False).text
+        return
+
+    if is_chat_engine:
+        response = engine.chat(query)
+    else:
+        response = engine.query(query)
+
+    lowest_score_file = None
+    lowest_score = sys.float_info.max
+    for node in response.source_nodes:
+        metadata = node.metadata
+        if 'filename' in metadata:
+            if node.score < lowest_score:
+                lowest_score = node.score
+                lowest_score_file = metadata['filename']
+
+    file_links = []
+    seen_files = set()  # Set to track unique file names
+    ts = calendar.timegm(time.gmtime())
+    temp_docs_folder_name = "Temp/Temp_Docs"
+    docs_path = os.path.join(os.getcwd(), temp_docs_folder_name, str(ts))
+    os.makedirs(docs_path, exist_ok=True)
+
+    # Generate links for the file with the highest aggregated score
+    if lowest_score_file:
+        abs_path = Path(os.path.join(os.getcwd(), lowest_score_file.replace('\\', '/')))
+        file_name = os.path.basename(abs_path)
+        doc_path = os.path.join(docs_path, file_name)
+        shutil.copy(abs_path, doc_path)
+
+        if file_name not in seen_files:  # Ensure the file hasn't already been processed
+            if data_source == 'directory':
+                file_link = f'<a data-link="{doc_path}">{file_name}</a>'
+            else:
+                exit("Wrong data_source type")
+            file_links.append(file_link)
+            seen_files.add(file_name)  # Mark file as processed
+
+    response_txt = str(response)
+    if file_links:
+        response_txt += "<br>Reference files:<br>" + "<br>".join(file_links)
+    if not lowest_score_file:  # If no file with a high score was found
+        response_txt = llm.complete(query).text
+    yield response_txt
+
+def stream_chatbot(query, chat_history, session_id):
+    
+    if selected_CLIP:
+        ts = calendar.timegm(time.gmtime())
+        temp_image_folder_name = "Temp/Temp_Images"
+        if os.path.isdir(temp_image_folder_name):                
+            try:
+                shutil.rmtree(os.path.join(os.getcwd(), temp_image_folder_name))
+            except Exception as e:
+                print("Exception during folder delete", e)
+        image_results_path = os.path.join(os.getcwd(), temp_image_folder_name, str(ts))
+        res_im_paths = clip_engine.query(query, image_results_path)
+        if len(res_im_paths) == 0:
+            yield "No supported images found in the selected folder"
+            torch.cuda.empty_cache()
+            gc.collect()
+            return
+        div_start = '<div class="chat-output-images">'
+        div_end = '</div>'
+        im_elements = ''
+        for i, im in enumerate(res_im_paths):
+            if i>2 : break # display atmost 3 images.
+            cur_data_link_src = temp_image_folder_name +"/" + str(ts) + "/" + os.path.basename(im)
+            cur_src = "file/" + temp_image_folder_name +"/" + str(ts) + "/" + os.path.basename(im)
+            im_elements += '<img data-link="{data_link_src}" src="{src}"/>'.format(src=cur_src, data_link_src=cur_data_link_src)
+        full_div = (div_start + im_elements + div_end)
+        folder_link = f'<a data-link="{image_results_path}">{"See all matches"}</a>'
+        prefix = ""
+        if(len(res_im_paths)>1): 
+            prefix = "Here are the top matching pictures from your dataset"
+        else:
+            prefix = "Here is the top matching picture from your dataset"
+        response = prefix + "<br>"+ full_div + "<br>"+ folder_link
+        yield response
+        torch.cuda.empty_cache()
+        gc.collect()
+        return
+
+    if data_source == "nodataset":
+        for response in call_llm_streamed(query):
+            yield response
+        return
+
+    if is_chat_engine:
+        response = engine.stream_chat(query)
+    else:
+        response = engine.query(query)
+
+    partial_response = ""
+    if len(response.source_nodes) == 0:
+        response = llm.stream_complete(query, formatted=False)
+        for token in response:
+            partial_response += token.delta
+            yield partial_response
+    else:
+        # Aggregate scores by file
+        lowest_score_file = None
+        lowest_score = sys.float_info.max
+
+        for node in response.source_nodes:
+            if 'filename' in node.metadata:
+                if node.score < lowest_score:
+                    lowest_score = node.score
+                    lowest_score_file = node.metadata['filename']
+
+        file_links = []
+        seen_files = set()
+        for token in response.response_gen:
+            partial_response += token
+            yield partial_response
+            time.sleep(0.05)
+
+        time.sleep(0.2)
+        ts = calendar.timegm(time.gmtime())
+        temp_docs_folder_name = "Temp/Temp_Docs"
+        docs_path = os.path.join(os.getcwd(), temp_docs_folder_name, str(ts))
+        os.makedirs(docs_path, exist_ok=True)
+
+        if lowest_score_file:
+            abs_path = Path(os.path.join(os.getcwd(), lowest_score_file.replace('\\', '/')))
+            file_name = os.path.basename(abs_path)
+            doc_path = os.path.join(docs_path, file_name)
+            shutil.copy(abs_path, doc_path)
+            if file_name not in seen_files:  # Check if file_name is already seen
+                if data_source == 'directory':
+                    file_link = f'<a data-link="{doc_path}">{file_name}</a>'
+                else:
+                    exit("Wrong data_source type")
+                file_links.append(file_link)
+                seen_files.add(file_name)  # Add file_name to the set
+
+        if file_links:
+            partial_response += "<br>Reference files:<br>" + "<br>".join(file_links)
+        yield partial_response
+
+    # call garbage collector after inference
+    torch.cuda.empty_cache()
+    gc.collect()
+
+
+interface = MainInterface(chatbot=stream_chatbot if streaming else chatbot, streaming=streaming)
+
+
+def on_shutdown_handler(session_id):
+    global llm, whisper_model, clip_model, clip_processor, clip_engine
+    import gc
+    if whisper_model is not None:        
+        whisper_model.unload_model()
+        del whisper_model
+        whisper_model = None
+    if llm is not None:
+        llm.unload_model()
+        del llm
+        llm = None
+    if clip_model is not None:
+        del clip_model
+        del clip_processor
+        del clip_engine
+        clip_model = None
+        clip_processor = None
+        clip_engine = None
+    temp_data_folder_name = "Temp"
+    if os.path.isdir(temp_data_folder_name):                
+        try:
+            shutil.rmtree(os.path.join(os.getcwd(), temp_data_folder_name))
+        except Exception as e:
+            print("Exception during temp folder delete", e)
+    # Force a garbage collection cycle
+    gc.collect()
+
+
+interface.on_shutdown(on_shutdown_handler)
+
+
+def reset_chat_handler(session_id):
+    global faiss_storage
+    global engine
+    print('reset chat called', session_id)
+    if selected_CLIP:
+        return
+    if is_chat_engine == True:
+        faiss_storage.reset_engine(engine)
+
+
+interface.on_reset_chat(reset_chat_handler)
+
+
+def on_dataset_path_updated_handler(source, new_directory, video_count, session_id):
+    print('data set path updated to ', source, new_directory, video_count, session_id)
+    global engine
+    global data_dir
+    if selected_CLIP:
+        data_dir = new_directory
+        generate_clip_engine(data_dir, model_config["model_path"], clip_model, clip_processor)
+        return
+    if source == 'directory':
+        if data_dir != new_directory:
+            data_dir = new_directory
+            generate_inferance_engine(data_dir)
+
+
+interface.on_dataset_path_updated(on_dataset_path_updated_handler)
+
+
+def on_model_change_handler(model, model_info, session_id):
+    global llm, embedded_model, engine, data_dir, service_context, clip_model, clip_processor, selected_CLIP, selected_model_name, embed_model, model_config, selected_ChatGLM, clip_engine
+    selected_model_name = model
+    selected_ChatGLM = False
+    
+    if llm is not None:
+        llm.unload_model()
+        del llm
+        llm = None
+    
+    if clip_model != None:
+        del clip_model
+        clip_model = None
+        del clip_processor
+        clip_processor = None
+        del clip_engine
+        clip_engine = None
+
+    torch.cuda.empty_cache()
+    gc.collect()
+    
+    cwd = os.getcwd()
+    model_config = get_model_config(config, selected_model_name)
+
+    selected_CLIP = False
+    if selected_model_name == "CLIP":
+        selected_CLIP = True
+        if clip_model == None:
+            clip_model = CLIPModel.from_pretrained(model_config["model_path"]).to('cuda')
+            clip_processor = CLIPProcessor.from_pretrained(model_config["model_path"])
+        generate_clip_engine(data_dir, model_config["model_path"], clip_model, clip_processor)
+        return
+
+    model_path = os.path.join(cwd, "model", model_info["id"], "engine") if "id" in model_info else None
+    engine_name = model_info["metadata"].get('engine', None)
+
+    if not model_path or not engine_name:
+        print("Model path or engine not provided in metadata")
+        return
+
+    if selected_model_name == "ChatGLM 3 6B int4 (Supports Chinese)":
+        selected_ChatGLM = True
+
+    model_name, _ = read_model_name(model_path)
+    prompt_template = LLMPromptTemplate()
+    text_qa_template_str = prompt_template.model_context_template(model_name)
+    selected_completion_to_prompt =  text_qa_template_str
+
+    #selected_completion_to_prompt = chatglm_completion_to_prompt if selected_ChatGLM else completion_to_prompt
+    llm = TrtLlmAPI(
+        model_path=model_path,
+        engine_name=engine_name,
+        tokenizer_dir=os.path.join(cwd, "model", model_info["id"] ,model_info["prerequisite"]["tokenizer_local_dir"] ) if "tokenizer_local_dir" in model_info["prerequisite"] else None,
+        temperature=model_info["metadata"].get("temperature"),
+        max_new_tokens=model_info["metadata"].get("max_new_tokens"),
+        context_window=model_info["metadata"].get("max_input_token"),
+        vocab_file=os.path.join(cwd, "model", model_info["id"] ,model_info["prerequisite"]["vocab_local_dir"], model_info["prerequisite"]["tokenizer_files"]["vocab_file"]) if "vocab_local_dir" in model_info["prerequisite"] else None,
+        messages_to_prompt=messages_to_prompt,
+        completion_to_prompt=selected_completion_to_prompt,
+        use_py_session=use_py_session,
+        add_special_tokens=add_special_tokens,
+        trtLlm_debug_mode=trtLlm_debug_mode,
+        verbose=verbose
+    )
+    if embed_model is None : embed_model = HuggingFaceEmbeddings(model_name=embedded_model)
+    if service_context is None:
+        service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model,
+                                                    context_window=model_config["max_input_token"], chunk_size=512,
+                                                    chunk_overlap=200)
+    else:
+        service_context = ServiceContext.from_service_context(service_context=service_context, llm=llm)
+    set_global_service_context(service_context)
+    generate_inferance_engine(data_dir)
+
+
+interface.on_model_change(on_model_change_handler)
+
+
+def on_dataset_source_change_handler(source, path, session_id):
+
+    global data_source, data_dir, engine
+    data_source = source
+
+    if data_source == "nodataset":
+        print(' No dataset source selected', session_id)
+        return
+    
+    print('dataset source updated ', source, path, session_id)
+    
+    if data_source == "directory":
+        data_dir = path
+    else:
+        print("Wrong data type selected")
+    generate_inferance_engine(data_dir)
+
+
+interface.on_dataset_source_updated(on_dataset_source_change_handler)
+
+def handle_regenerate_index(source, path, session_id):
+    if selected_CLIP:
+        generate_clip_engine(data_dir, model_config["model_path"], clip_model, clip_processor, force_rewrite=True)
+    else:
+        generate_inferance_engine(path, force_rewrite=True)
+    print("on regenerate index", source, path, session_id)
+
+
+def mic_init_handler():
+    global whisper_model, whisper_model_loaded, enable_asr
+    enable_asr = config["models"]["enable_asr"]
+    if not enable_asr:
+        return False
+    vid_mem_info = nvmlDeviceGetMemoryInfo(nvmlDeviceGetHandleByIndex(0))
+    free_vid_mem = vid_mem_info.free / (1024*1024)
+    print("free video memory in MB = ", free_vid_mem)
+    if whisper_model is not None:
+        whisper_model.unload_model()
+        del whisper_model
+        whisper_model = None
+    whisper_model = WhisperTRTLLM(asr_engine_path, assets_dir=asr_assets_path)
+    whisper_model_loaded = True
+    return True
+
+interface.on_mic_button_click(mic_init_handler)
+
+def mic_recording_done_handler(audio_path):
+    transcription = ""
+    global whisper_model, enable_asr, whisper_model_loaded
+    if not enable_asr:
+        return ""
+    
+    # Check and wait until model is loaded before running it.
+    checks_left_for_model_loading = 40
+    sleep_time = 0.2
+    while checks_left_for_model_loading>0 and not whisper_model_loaded:
+        time.sleep(sleep_time)
+        checks_left_for_model_loading -= 1
+    assert checks_left_for_model_loading>0, f"Whisper model loading not finished even after {(checks_left_for_model_loading*sleep_time)} seconds"
+    if checks_left_for_model_loading == 0:
+        return ""
+
+    # Covert the audio file into required sampling rate
+    current_sampling_rate, data = wavfile.read(audio_path)
+    new_sampling_rate = 16000
+    number_of_samples = round(len(data) * float(new_sampling_rate) / current_sampling_rate)
+    data = sps.resample(data, number_of_samples)
+    new_file_path = os.path.join( os.path.dirname(audio_path), "whisper_audio_input.wav" )
+    wavfile.write(new_file_path, new_sampling_rate, data.astype(np.int16))
+    language = "english"
+    if selected_ChatGLM: language = "chinese"
+    transcription = decode_audio_file( new_file_path, whisper_model, language=language, mel_filters_dir=asr_assets_path)
+
+    if whisper_model is not None:        
+        whisper_model.unload_model()
+        del whisper_model
+        whisper_model = None
+    whisper_model_loaded = False
+    return transcription
+
+interface.on_mic_recording_done(mic_recording_done_handler)
+
+def model_download_handler(model_info):
+    download_path = os.path.join(os.getcwd(), "model")
+    status = download_model_by_name(model_info=model_info,  download_path=download_path)
+    print(f"Model download status: {status}")
+    return status
+
+interface.on_model_downloaded(model_download_handler)
+
+def model_install_handler(model_info):
+    download_path = os.path.join(os.getcwd(), "model")
+    global llm, service_context
+    #unload the current model
+    if llm is not None:
+        llm.unload_model()
+        del llm
+        llm = None
+    # build the engine
+    status = build_engine_by_name(model_info=model_info , download_path= download_path)
+    print(f"Engine build status: {status}")
+    return status
+
+interface.on_model_installed(model_install_handler)
+
+def model_delete_handler(model_info):
+    print("Model deleting ", model_info)
+    model_dir = os.path.join(os.getcwd(), "model", model_info['id'])
+    isSuccess = True
+    if os.path.isdir(model_dir): 
+        try:
+            shutil.rmtree(model_dir)
+        except Exception as e:
+            print("Exception during temp folder delete", e)
+            isSuccess = False
+    return isSuccess
+
+interface.on_model_delete(model_delete_handler)
+
+interface.on_regenerate_index(handle_regenerate_index)
+# render the interface
+interface.render()

deploy-docs.yml

@@ -0,0 +1,59 @@
+name: Deploy Docs to GitHub Pages
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Build Docusaurus
+    runs-on: ubuntu-latest
+    if: github.repository == 'OpenDevin/OpenDevin'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: npm
+          cache-dependency-path: docs/package-lock.json
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Generate Python Docs
+        run: rm -rf docs/modules/python && pip install pydoc-markdown && pydoc-markdown
+      - name: Install dependencies
+        run: cd docs && npm ci
+      - name: Build website
+        run: cd docs && npm run build
+
+      - name: Upload Build Artifact
+        if: github.ref == 'refs/heads/main'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: docs/build
+
+  deploy:
+    name: Deploy to GitHub Pages
+    needs: build
+    if: github.ref == 'refs/heads/main' && github.repository == 'OpenDevin/OpenDevin'
+    # Grant GITHUB_TOKEN the permissions required to make a Pages deployment
+    permissions:
+      pages: write # to deploy to Pages
+      id-token: write # to verify the deployment originates from an appropriate source
+    # Deploy to the github-pages environment
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

dummy-agent-test.yml

@@ -0,0 +1,33 @@
+name: Run e2e test with dummy agent
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+
+env:
+  PERSIST_SANDBOX : "false"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Set up environment
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+          poetry install --without evaluation
+          poetry run playwright install --with-deps chromium
+          wget https://huggingface.co/BAAI/bge-small-en-v1.5/raw/main/1_Pooling/config.json -P /tmp/llama_index/models--BAAI--bge-small-en-v1.5/snapshots/5c38ec7c405ec4b44b94cc5a9bb96e735b38267a/1_Pooling/
+      - name: Run tests
+        run: |
+          poetry run python opendevin/core/main.py -t "do a flip" -m ollama/not-a-model -d ./workspace/ -c DummyAgent

ghcr.yml

@@ -0,0 +1,82 @@
+name: Publish Docker Image
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+on:
+  push:
+    branches:
+    - main
+    tags:
+      - '*'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual trigger'
+        required: true
+        default: ''
+
+jobs:
+  ghcr_build_and_push:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      packages: write
+
+    strategy:
+      matrix:
+        image: ["app", "sandbox"]
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@main
+        with:
+          # this might remove tools that are actually needed,
+          # if set to "true" but frees about 6 GB
+          tool-cache: true
+
+          # all of these default to true, but feel free to set to
+          # "false" if necessary for your workflow
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          docker-images: false
+          swap-storage: true
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to ghcr
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push ${{ matrix.image }}
+        if: "!github.event.pull_request.head.repo.fork"
+        run: |
+          ./containers/build.sh ${{ matrix.image }} ${{ github.repository_owner }} --push
+
+      - name: Build ${{ matrix.image }}
+        if: "github.event.pull_request.head.repo.fork"
+        run: |
+          ./containers/build.sh ${{ matrix.image }} ${{ github.repository_owner }}
+
+  docker_build_success:
+    name: Docker Build Success
+    runs-on: ubuntu-latest
+    needs: ghcr_build_and_push
+    steps:
+    - run: echo Done!

lint.yml

@@ -0,0 +1,57 @@
+name: Lint
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+
+jobs:
+  lint-frontend:
+    name: Lint frontend
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Node.js 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install dependencies
+        run: |
+          cd frontend
+          npm install --frozen-lockfile
+
+      - name: Lint
+        run: |
+          cd frontend
+          npm run lint
+
+  lint-python:
+    name: Lint python
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.11
+          cache: 'pip'
+      - name: Install pre-commit
+        run: pip install pre-commit==3.7.0
+      - name: Run pre-commit hooks
+        if: github.ref != 'refs/heads/main'
+        run: |
+          git fetch https://github.com/OpenDevin/OpenDevin.git main:main && \
+          pre-commit run \
+            --files \
+            $(git diff --name-only $(git merge-base main $(git branch --show-current)) $(git branch --show-current) | tr '\n' ' ') \
+            --show-diff-on-failure \
+            --config ./dev_config/python/.pre-commit-config.yaml

review-pr.yml

@@ -0,0 +1,69 @@
+name: Use OpenDevin to Review Pull Request
+
+on:
+  pull_request:
+    types: [synchronize, labeled]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dogfood:
+    if: contains(github.event.pull_request.labels.*.name, 'review-this')
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/opendevin/opendevin
+      volumes:
+        - /var/run/docker.sock:/var/run/docker.sock
+
+    steps:
+    - name: install git, github cli
+      run: |
+        apt-get install -y git gh
+        git config --global --add safe.directory $PWD
+
+    - name: Checkout Repository
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.pull_request.base.ref }} # check out the target branch
+
+    - name: Download Diff
+      run: |
+        curl -O "${{ github.event.pull_request.diff_url }}" -L
+
+    - name: Write Task File
+      run: |
+        echo "Your coworker wants to apply a pull request to this project. Read and review ${{ github.event.pull_request.number }}.diff file. Create a review-${{ github.event.pull_request.number }}.txt and write your concise comments and suggestions there." > task.txt
+        echo "" >> task.txt
+        echo "Title" >> task.txt
+        echo "${{ github.event.pull_request.title }}" >> task.txt
+        echo "" >> task.txt
+        echo "Description" >> task.txt
+        echo "${{ github.event.pull_request.body }}" >> task.txt
+        echo "" >> task.txt
+        echo "Diff file is: ${{ github.event.pull_request.number }}.diff" >> task.txt
+
+    - name: Run OpenDevin
+      env:
+        LLM_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        SANDBOX_TYPE: exec
+      run: |
+        WORKSPACE_MOUNT_PATH=$GITHUB_WORKSPACE python ./opendevin/core/main.py -i 50 -f task.txt -d $GITHUB_WORKSPACE
+        rm task.txt
+
+    - name: Check if review file is non-empty
+      id: check_file
+      run: |
+        ls -la
+        if [[ -s review-${{ github.event.pull_request.number }}.txt ]]; then
+          echo "non_empty=true" >> $GITHUB_OUTPUT
+        fi
+      shell: bash
+
+    - name: Create PR review if file is non-empty
+      env:
+        GH_TOKEN: ${{ github.token }}
+      if: steps.check_file.outputs.non_empty == 'true'
+      run: |
+        gh pr review ${{ github.event.pull_request.number }} --comment --body-file "review-${{ github.event.pull_request.number }}.txt"

run-integration-tests.yml

@@ -0,0 +1,104 @@
+name: Run Integration Tests
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**/*.md'
+      - 'frontend/**'
+      - 'docs/**'
+      - 'evaluation/**'
+  pull_request:
+
+env:
+  PERSIST_SANDBOX : "false"
+
+jobs:
+  integration-tests-on-linux:
+    name: Integration Tests on Linux
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11"]
+        sandbox: ["ssh", "exec", "local"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install poetry via pipx
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'poetry'
+
+      - name: Install Python dependencies using Poetry
+        run: poetry install
+
+      - name: Build Environment
+        run: make build
+
+      - name: Run Integration Tests
+        env:
+          SANDBOX_TYPE: ${{ matrix.sandbox }}
+        run: |
+          TEST_IN_CI=true TEST_ONLY=true ./tests/integration/regenerate.sh
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  integration-tests-on-mac:
+    name: Integration Tests on MacOS
+    runs-on: macos-13
+    if: contains(github.event.pull_request.title, 'mac') || contains(github.event.pull_request.title, 'Mac')
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11"]
+        sandbox: ["ssh"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install poetry via pipx
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'poetry'
+
+      - name: Install Python dependencies using Poetry
+        run: poetry install
+
+      - name: Install & Start Docker
+        run: |
+          brew install colima docker
+          colima start
+
+          # For testcontainers to find the Colima socket
+          # https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#cannot-connect-to-the-docker-daemon-at-unixvarrundockersock-is-the-docker-daemon-running
+          sudo ln -sf $HOME/.colima/default/docker.sock /var/run/docker.sock
+
+      - name: Build Environment
+        run: make build
+
+      - name: Run Integration Tests
+        env:
+          SANDBOX_TYPE: ${{ matrix.sandbox }}
+        run: |
+          TEST_IN_CI=true TEST_ONLY=true ./tests/integration/regenerate.sh
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

run-unit-tests.yml

@@ -0,0 +1,129 @@
+name: Run Unit Tests
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**/*.md'
+      - 'frontend/**'
+      - 'docs/**'
+      - 'evaluation/**'
+  pull_request:
+
+env:
+  PERSIST_SANDBOX : "false"
+
+jobs:
+  test-on-macos:
+    name: Test on macOS
+    runs-on: macos-13
+    env:
+      INSTALL_DOCKER: "0" # Set to '0' to skip Docker installation
+    strategy:
+      matrix:
+        python-version: ["3.11"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install poetry via pipx
+        run: pipx install poetry
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "poetry"
+
+      - name: Install Python dependencies using Poetry
+        run: poetry install
+
+      - name: Install & Start Docker
+        if: env.INSTALL_DOCKER == '1'
+        run: |
+          brew install colima docker
+          colima start
+
+          # For testcontainers to find the Colima socket
+          # https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#cannot-connect-to-the-docker-daemon-at-unixvarrundockersock-is-the-docker-daemon-running
+          sudo ln -sf $HOME/.colima/default/docker.sock /var/run/docker.sock
+
+      - name: Build Environment
+        run: make build
+
+      - name: Run Tests
+        run: poetry run pytest --forked --cov=agenthub --cov=opendevin --cov-report=xml ./tests/unit -k "not test_sandbox"
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+  test-on-linux:
+    name: Test on Linux
+    runs-on: ubuntu-latest
+    env:
+      INSTALL_DOCKER: "0" # Set to '0' to skip Docker installation
+    strategy:
+      matrix:
+        python-version: ["3.11"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install poetry via pipx
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "poetry"
+
+      - name: Install Python dependencies using Poetry
+        run: poetry install --without evaluation
+
+      - name: Build Environment
+        run: make build
+
+      - name: Run Tests
+        run: poetry run pytest --forked --cov=agenthub --cov=opendevin --cov-report=xml ./tests/unit -k "not test_sandbox"
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  test-for-sandbox:
+    name: Test for Sandbox
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install poetry via pipx
+        run: pipx install poetry
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: "poetry"
+
+      - name: Install Python dependencies using Poetry
+        run: poetry install
+
+      - name: Build Environment
+        run: make build
+
+      - name: Run Integration Test for Sandbox
+        run: |
+          poetry run pytest --cov=agenthub --cov=opendevin --cov-report=xml -s ./tests/unit/test_sandbox.py
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

solve-issue.yml

@@ -0,0 +1,109 @@
+name: Use OpenDevin to Resolve GitHub Issue
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  contents: write
+  pull-requests: write
+  issues: write
+
+jobs:
+  dogfood:
+    if: github.event.label.name == 'solve-this'
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/opendevin/opendevin
+      volumes:
+        - /var/run/docker.sock:/var/run/docker.sock
+
+    steps:
+    - name: install git, github cli
+      run: apt-get install -y git gh
+
+    - name: Checkout Repository
+      uses: actions/checkout@v4
+
+    - name: Write Task File
+      env:
+        ISSUE_TITLE: ${{ github.event.issue.title }}
+        ISSUE_BODY: ${{ github.event.issue.body }}
+      run: |
+        echo "TITLE:" > task.txt
+        echo "${ISSUE_TITLE}" >> task.txt
+        echo "" >> task.txt
+        echo "BODY:" >> task.txt
+        echo "${ISSUE_BODY}" >> task.txt
+
+    - name: Run OpenDevin
+      env:
+        ISSUE_TITLE: ${{ github.event.issue.title }}
+        ISSUE_BODY: ${{ github.event.issue.body }}
+        LLM_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        SANDBOX_TYPE: exec
+      run: |
+        WORKSPACE_MOUNT_PATH=$GITHUB_WORKSPACE python ./opendevin/core/main.py -i 50 -f task.txt -d $GITHUB_WORKSPACE
+        rm task.txt
+
+    - name: Setup Git, Create Branch, and Commit Changes
+      run: |
+        # Setup Git configuration
+        git config --global --add safe.directory $PWD
+        git config --global user.name 'OpenDevin'
+        git config --global user.email 'OpenDevin@users.noreply.github.com'
+
+        # Create a unique branch name with a timestamp
+        BRANCH_NAME="fix/${{ github.event.issue.number }}-$(date +%Y%m%d%H%M%S)"
+
+        # Checkout new branch
+        git checkout -b $BRANCH_NAME
+
+        # Add all changes to staging, except task.txt
+        git add --all -- ':!task.txt'
+
+        # Commit the changes, if any
+        git commit -m "OpenDevin: Resolve Issue #${{ github.event.issue.number }}"
+        if [ $? -ne 0 ]; then
+          echo "No changes to commit."
+          exit 0
+        fi
+
+        # Push changes
+        git push --set-upstream origin $BRANCH_NAME
+
+    - name: Fetch Default Branch
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        # Fetch the default branch using gh cli
+        DEFAULT_BRANCH=$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name)
+        echo "Default branch is $DEFAULT_BRANCH"
+        echo "DEFAULT_BRANCH=$DEFAULT_BRANCH" >> $GITHUB_ENV
+
+    - name: Generate PR
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        # Create PR and capture URL
+        PR_URL=$(gh pr create \
+          --title "OpenDevin: Resolve Issue #2" \
+          --body "This PR was generated by OpenDevin to resolve issue #2" \
+          --repo "foragerr/OpenDevin" \
+          --head "${{ github.head_ref }}" \
+          --base "${{ env.DEFAULT_BRANCH }}" \
+          | grep -o 'https://github.com/[^ ]*')
+
+        # Extract PR number from URL
+        PR_NUMBER=$(echo "$PR_URL" | grep -o '[0-9]\+$')
+
+        # Set environment vars
+        echo "PR_URL=$PR_URL" >> $GITHUB_ENV
+        echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV
+
+    - name: Post Comment
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        gh issue comment ${{ github.event.issue.number }} \
+          -b "OpenDevin raised [PR #${{ env.PR_NUMBER }}](${{ env.PR_URL }}) to resolve this issue."

stale.yml

@@ -0,0 +1,29 @@
+name: 'Close stale issues'
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          # Aggressively close issues that have been explicitly labeled `age-out`
+          any-of-labels: age-out
+          stale-issue-message: 'This issue is stale because it has been open for 7 days with no activity. Remove stale label or comment or this will be closed in 1 day.'
+          close-issue-message: 'This issue was closed because it has been stalled for over 7 days with no activity.'
+          stale-pr-message: 'This PR is stale because it has been open for 7 days with no activity. Remove stale label or comment or this will be closed in 1 days.'
+          close-pr-message: 'This PR was closed because it has been stalled for over 7 days with no activity.'
+          days-before-stale: 7
+          days-before-close: 1
+
+      - uses: actions/stale@v9
+        with:
+          # Be more lenient with other issues
+          stale-issue-message: 'This issue is stale because it has been open for 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          close-issue-message: 'This issue was closed because it has been stalled for over 30 days with no activity.'
+          stale-pr-message: 'This PR is stale because it has been open for 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          close-pr-message: 'This PR was closed because it has been stalled for over 30 days with no activity.'
+          days-before-stale: 30
+          days-before-close: 7