Upload 3 files

app.py

@@ -0,0 +1,402 @@
+import streamlit as st
+from streamlit_ace import st_ace
+import subprocess
+import time
+import re
+import asyncio
+import json
+import uuid
+import os
+from code_assistant_runnable import get_runnable
+
+from langchain_core.messages import SystemMessage, AIMessage, HumanMessage, ToolMessage 
+
+# Set up page configuration
+st.set_page_config(page_title="AI Code Editor", 
+                   page_icon=":computer:", 
+                   layout="wide")
+
+@st.cache_resource
+def create_code_assistant_instance():
+    try:
+        # Import torch first to ensure proper initialization
+        import torch
+        torch.set_grad_enabled(False)  # Disable gradients since we're only doing inference
+        
+        return get_runnable()
+    except Exception as e:
+        st.error(f"Error initializing chatbot: {str(e)}")
+        return None
+
+chatbot = create_code_assistant_instance()
+
+
+# Initialize session states
+if 'messages' not in st.session_state:
+    st.session_state.messages = [
+        AIMessage(content="Hello, I am your coding assistant. How can I help you?"),
+    ]
+
+
+
+if 'editor_code' not in st.session_state:
+    st.session_state.editor_code = ''
+
+# Constants
+EDITOR_HEIGHT = 400
+OUTPUT_HEIGHT = 150
+
+# Minimal CSS for styling
+st.markdown("""
+    <style type="text/css">
+        .output-container {
+            background-color: rgba(17, 19, 23, 0.8);
+            border-radius: 4px;
+            padding: 1rem;
+            margin-top: 0.5rem;
+            min-height: 150px;
+            color: white;
+        }
+        
+        .placeholder-text {
+            color: gray;
+            font-style: italic;
+        }
+        
+        /* Remove extra padding */
+        .block-container {
+            padding-top: 1rem !important;
+        }
+        
+        /* Ensure chat messages are visible */
+        .stChatMessage {
+            background-color: rgba(17, 19, 23, 0.8) !important;
+        }
+
+        /* Style section headers consistently */
+        .section-header {
+            font-size: 1rem;
+            margin-bottom: 1rem;
+            color: rgb(250, 250, 250);
+            font-weight: 500;
+        }
+
+        /* Ensure columns align at the top */
+        .column-container {
+            display: flex;
+            align-items: flex-start;
+        }
+            
+        /* Loading indicator styles */
+        .loading-spinner {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem;
+            border-radius: 0.25rem;
+            background-color: rgba(17, 19, 23, 0.8);
+        }
+        
+        .loading-text {
+            color: #ffffff;
+            font-size: 0.875rem;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+
+def analyze_code(code, language):
+    """
+    Basic code analysis function that looks for common issues
+    """
+    analysis = []
+    
+    if language == "python":
+        # Check for basic Python issues
+        if "while" in code and "break" not in code:
+            analysis.append("⚠️ While loop detected without break condition - check for infinite loops")
+        
+        if "except:" in code and "except Exception:" not in code:
+            analysis.append("⚠️ Bare except clause detected - consider catching specific exceptions")
+        
+        if "print" in code and "if __name__ == '__main__':" not in code:
+            analysis.append("💡 Consider adding main guard for scripts with print statements")
+        
+        if re.search(r'^\s+', code, re.MULTILINE):
+            analysis.append("🔍 Mixed indentation detected - check spacing")
+            
+    elif language == "rust":
+        if "unwrap()" in code:
+            analysis.append("⚠️ Usage of unwrap() detected - consider proper error handling")
+        
+        if "mut" not in code and len(code) > 50:
+            analysis.append("💡 No mutable variables detected - verify if intentional")
+
+    if not analysis:
+        analysis.append("✅ No immediate issues detected in the code")
+    
+    return "\n".join(analysis)
+
+def dummy_ai_response(question, code_context, language):
+    """
+    Dummy AI response function with basic code context awareness
+    """
+    time.sleep(1)  # Simulate processing time
+    
+    if "debug" in question.lower():
+        return f"Here's my analysis of your {language} code:\n" + analyze_code(code_context, language)
+    
+    if "how" in question.lower() and "implement" in question.lower():
+        return f"To implement this in {language}, you might want to consider:\n1. Breaking down the problem\n2. Using appropriate data structures\n3. Following {language} best practices"
+    
+    if "error" in question.lower() or "not working" in question.lower():
+        return "Let me help you debug that. Could you:\n1. Share the specific error message\n2. Describe what you expected to happen\n3. Describe what actually happened"
+    
+    return f"I see you're working with {language}. Could you clarify what specific help you need with your code?"
+
+def run_python_code(code):
+    try:
+        with open("temp_code.py", "w") as f:
+            f.write(code)
+        result = subprocess.run(["python", "temp_code.py"], 
+                              capture_output=True, 
+                              text=True)
+        return result.stderr if result.stderr else result.stdout
+    except Exception as e:
+        return f"Error: {e}"
+
+def run_rust_code(code):
+    with open('code.rs', 'w') as file:
+        file.write(code)
+    
+    compile_process = subprocess.Popen(['rustc', 'code.rs'], 
+                                     stdout=subprocess.PIPE, 
+                                     stderr=subprocess.PIPE, 
+                                     text=True)
+    compile_output, compile_errors = compile_process.communicate()
+    
+    if compile_process.returncode != 0:
+        return f"Compilation Error: {compile_errors}"
+    
+    run_process = subprocess.Popen(['./code'], 
+                                 stdout=subprocess.PIPE, 
+                                 stderr=subprocess.PIPE, 
+                                 text=True)
+    run_output, run_errors = run_process.communicate()
+    return run_output if not run_errors else run_errors
+
+def run_js_code():
+
+    pass
+
+def dummy_auto_complete(code: str, language: str = None) -> str:
+    """
+    Dummy function to simulate LLM code completion
+    Args:
+        code (str): The incomplete code in the editor
+        language (str, optional): Selected programming language
+    Returns:
+        str: The completed code
+    """
+    time.sleep(2)  # Simulate processing time
+    
+    # Example completions based on language
+    completions = {
+        "python": """# Function to calculate sum
+def calculate_sum(a: int, b: int) -> int:
+    '''Calculate sum of two integers'''
+    return a + b""",
+        
+        "javascript": """// Function to calculate sum
+function calculateSum(a, b) {
+    return a + b;
+}""",
+        
+        "rust": """// Function to calculate sum
+fn calculate_sum(a: i32, b: i32) -> i32 {
+    a + b
+}"""
+    }
+    
+    # Return language-specific completion or default to Python
+    return completions.get(language, completions["python"])
+
+# Sidebar settings
+with st.sidebar:
+    st.title("SolCoder")
+    st.header("Solana AI Code Editor")
+    theme = st.selectbox("Editor Theme",
+        ["monokai", "github", "solarized_dark", "solarized_light", "dracula"])
+    font_size = st.slider("Font Size", 12, 24, 14)
+    show_gutter = st.checkbox("Show Line Numbers", value=True)
+    language = st.selectbox("Language", ["python", "javascript", "rust"], index=0)
+
+# Create two columns for main layout
+col1, col2 = st.columns([3, 2])
+
+# Left Column - Code Editor and Output
+with col1:
+    st.subheader("")
+    st.subheader("Code Editor")
+    st.markdown("Write your code below and use the buttons to run or debug")
+    
+    # Code editor
+    editor = st_ace(
+        value=st.session_state.editor_code,
+        language=language,
+        theme=theme,
+        font_size=font_size,
+        show_gutter=show_gutter,
+        auto_update=True,
+        height=EDITOR_HEIGHT,
+        key="editor"
+    )
+    
+    # Buttons - Modified to include three columns
+    button_cols = st.columns(3)
+    with button_cols[0]:
+        auto_complete_btn = st.button("Auto-Complete", use_container_width=True)
+    with button_cols[1]:
+        run_btn = st.button("Run Code", use_container_width=True)
+    with button_cols[2]:
+        debug_btn = st.button("Debug Code", use_container_width=True)
+    
+    # Handle auto-complete button click
+    if auto_complete_btn:
+        with st.spinner("Generating code completion..."):
+            try:
+                # Get completed code from dummy function
+                completed_code = dummy_auto_complete(st.session_state.editor_code, language)
+                
+
+                st.markdown(f'<div class="output-area">```{completed_code}```</div>', unsafe_allow_html=True)
+                
+                # # Update editor content in session state
+                st.session_state.editor_code = completed_code
+                
+                # Show success message
+                st.success("Code successfully completed!")
+                
+            except Exception as e:
+                st.error(f"Error during code completion: {str(e)}")
+    
+    # Output area - simplified container structure
+    if run_btn:
+        output = run_python_code(editor) if language == "python" else \
+                run_rust_code(editor) if language == "rust" else \
+                "Currently, only Python and Rust execution is supported."
+        st.markdown(f'<div class="output-area">{output}</div>', unsafe_allow_html=True)
+    else:
+        st.markdown('<div class="output-area placeholder-text">Code output will appear here...</div>', 
+                   unsafe_allow_html=True)
+
+def format_ai_response(response):
+    """Format AI response into readable message"""
+    if isinstance(response, dict):
+        # Extract meaningful content from response structure
+        if 'generation' in response:
+            message = response['generation']
+            # Parse structured response appropriately
+            formatted_content = []
+            if hasattr(message, 'prefix'):
+                formatted_content.append(message.prefix)
+            if hasattr(message, 'imports'):
+                formatted_content.append(f"```\n{message.imports}\n```")
+            if hasattr(message, 'code'):
+                formatted_content.append(f"```\n{message.code}\n```")
+            return "\n".join(formatted_content)
+    return str(response)  # Fallback for simple responses
+
+
+# Right Column - Chat Interface
+with col2:
+    # Match header styling with the code section
+    # st.markdown('<p class="section-header">AI Assistant Chat</p>', unsafe_allow_html=True)
+    st.subheader("")
+    st.subheader("Code Assistant Agent")
+    
+    
+
+    # conversation
+
+    def validate_message(message):
+        """Validate message before adding to history"""
+        if not isinstance(message, (AIMessage, HumanMessage)):
+            return False
+        if not message.content or not isinstance(message.content, str):
+            return False
+        return True
+
+    def add_message_to_history(message):
+        """Safely add message to chat history"""
+        if validate_message(message):
+            st.session_state.messages.append(message)
+            return True
+        return False
+    
+    # Update message display section
+    for message in st.session_state.messages:
+        if isinstance(message, AIMessage):
+            with st.chat_message("AI"):
+                # Handle code blocks in message
+                content = message.content
+                if "```" in content:
+                    parts = content.split("```")
+                    for i, part in enumerate(parts):
+                        if i % 2 == 0:  # Regular text
+                            if part.strip():
+                                st.markdown(part)
+                        else:  # Code block
+                            st.code(part)
+                else:
+                    st.markdown(content)
+        elif isinstance(message, HumanMessage):
+            with st.chat_message("Human"):
+                st.markdown(message.content)
+    
+
+    
+    # Clear chat button
+    if st.button("Clear Chat", use_container_width=True):
+        st.session_state.messages = []
+        st.rerun()
+
+    if prompt := st.chat_input("Ask about writing solana code..."):
+        user_message = HumanMessage(content=prompt)
+        
+        # Add user message to history
+        if add_message_to_history(user_message):
+            with st.chat_message("AI"):
+                # Create a placeholder for the loading indicator
+                response_placeholder = st.empty()
+                
+                # Show loading message
+                with response_placeholder:
+                    with st.spinner("AI is thinking..."):
+                        try:
+                            # Get AI response
+                            ai_response = chatbot.invoke({
+                                "messages": [("user", prompt)], 
+                                "iterations": 0, 
+                                "error": ""
+                            })
+                            
+                            # Format and add AI response
+                            formatted_response = format_ai_response(ai_response)
+                            ai_message = AIMessage(content=formatted_response)
+                            
+                            # Clear the loading indicator and show the response
+                            response_placeholder.empty()
+                            st.markdown(formatted_response)
+                            
+                            # Add to history
+                            add_message_to_history(ai_message)
+                            
+                            # Only rerun after successful processing
+                            st.rerun()
+                            
+                        except Exception as e:
+                            response_placeholder.error(f"Error generating response: {str(e)}")
+    
+
+

code_assistant_runnable.py

@@ -0,0 +1,644 @@
+from langchain_openai import ChatOpenAI
+from langchain_ollama import ChatOllama
+from langchain_groq import ChatGroq
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import WebBaseLoader
+# from langchain_community.vectorstores import Chroma
+from langchain_chroma import Chroma
+
+from langchain_community.embeddings import HuggingFaceBgeEmbeddings
+import pickle
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+
+from typing import List
+from typing_extensions import TypedDict
+from langgraph.graph import END, StateGraph, START
+
+import subprocess
+import time
+import re
+import json
+import os
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+
+# Add after your imports
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# llm = ChatOllama(model="codestral")
+expt_llm = "gpt-4o-mini"
+llm = ChatOpenAI(temperature=0, model=expt_llm)
+
+## Create retrieval from existing store
+
+# Load the existing vectorstore
+
+# Load an existing (saved) embedding model from a pickle file
+
+model_path = "/Users/user/Projects/LLM_Projects/Hackathon/SACE/Model/embedding_model.pkl"
+with open(model_path, 'rb') as f:
+    embedding_model = pickle.load(f)
+
+print("Loaded embedding model successfully")
+
+vectorstore = Chroma(
+    collection_name="solcoder-chroma",
+    embedding_function=embedding_model,
+    persist_directory="solcoder-db"
+)
+
+retriever = vectorstore.as_retriever()
+
+
+# Grader prompt
+code_gen_prompt = ChatPromptTemplate(
+    [
+        (
+            "system",
+            """<instructions> You are a coding assistant with expertise in Solana Blockchain ecosystem. \n 
+    Here is a set of Solana development documentation based on a user question:  \n ------- \n  {context} \n ------- \n 
+    Answer the user  question based on the above provided documentation. Ensure any code you provide can be executed with all required imports and variables \n
+    defined. Structure your answer: 1) a prefix describing the code solution, 2) the imports, 3) the functioning code block. \n
+    Invoke the code tool to structure the output correctly. </instructions> \n Here is the user question:""",
+        ),
+        ("placeholder", "{messages}"),
+    ]
+)
+
+
+# Data model
+class code(BaseModel):
+    """Schema for code solutions to questions about Solana development."""
+
+    prefix: str = Field(description="Description of the problem and approach")
+    imports: str = Field(description="Code block import statements")
+    code: str = Field(description="Code block not including import statements")
+    language: str = Field(description="programming language the code is implemented")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "prefix": "To read the balance of an account from the Solana network, you can use the `@solana/web3.js` library.",
+                "imports": 'import { clusterApiUrl, Connection, PublicKey, LAMPORTS_PER_SOL,} from "@solana/web3.js";',
+                "code":"""const connection = new Connection(clusterApiUrl("devnet"), "confirmed");
+                            const wallet = new PublicKey("nicktrLHhYzLmoVbuZQzHUTicd2sfP571orwo9jfc8c");
+                            
+                            const balance = await connection.getBalance(wallet);
+                            console.log(`Balance: ${balance / LAMPORTS_PER_SOL} SOL`);""",
+                "language":"typescript"
+
+            }
+        }
+
+
+# expt_llm = "codestral"
+# llm = ChatOllama(temperature=0, model=expt_llm)
+
+
+# Post-processing
+def format_docs(docs):
+    return "\n\n".join(doc.page_content for doc in docs)
+
+
+
+structured_llm = code_gen_prompt | llm.with_structured_output(code, include_raw=True)
+
+# Optional: Check for errors in case tool use is flaky
+def check_llm_output(tool_output):
+    """Check for parse error or failure to call the tool"""
+
+    # Error with parsing
+    if tool_output["parsing_error"]:
+        # Report back output and parsing errors
+        print("Parsing error!")
+        raw_output = str(tool_output["raw"].content)
+        error = tool_output["parsing_error"]
+        raise ValueError(
+            f"Error parsing your output! Be sure to invoke the tool. Output: {raw_output}. \n Parse error: {error}"
+        )
+
+    # Tool was not invoked
+    elif not tool_output["parsed"]:
+        print("Failed to invoke tool!")
+        raise ValueError(
+            "You did not use the provided tool! Be sure to invoke the tool to structure the output."
+        )
+    return tool_output
+
+
+# Chain with output check
+code_chain_raw = (
+    code_gen_prompt | structured_llm | check_llm_output
+)
+
+def insert_errors(inputs):
+    """Insert errors for tool parsing in the messages"""
+
+    # Get errors
+    error = inputs["error"]
+    messages = inputs["messages"]
+    messages += [
+        (
+            "assistant",
+            f"Retry. You are required to fix the parsing errors: {error} \n\n You must invoke the provided tool.",
+        )
+    ]
+    return {
+        "messages": messages,
+        "context": inputs["context"],
+    }
+
+
+# This will be run as a fallback chain
+fallback_chain = insert_errors | code_chain_raw
+
+N = 3  # Max re-tries
+
+code_gen_chain_re_try = code_chain_raw.with_fallbacks(
+    fallbacks=[fallback_chain] * N, exception_key="error"
+)
+
+
+def parse_output(solution):
+    """When we add 'include_raw=True' to structured output,
+    it will return a dict w 'raw', 'parsed', 'parsing_error'."""
+
+    return solution["parsed"]
+
+# Optional: With re-try to correct for failure to invoke tool
+code_gen_chain = code_gen_chain_re_try | parse_output
+
+# No re-try
+# code_gen_chain = code_gen_prompt | structured_llm | parse_output
+
+
+### Create State
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+
+    Attributes:
+        error : Binary flag for control flow to indicate whether test error was tripped
+        messages : With user question, error messages, reasoning
+        generation : Code solution
+        iterations : Number of tries
+    """
+
+    error: str
+    messages: List
+    generation: List
+    iterations: int
+
+### HELPER FUNCTIONS
+
+def check_node_typescript_installation():
+    """Check if Node.js and TypeScript are properly installed"""
+    try:
+        # Check Node.js
+        node_version = subprocess.run(["node", "--version"], 
+                                   capture_output=True, 
+                                   text=True)
+        if node_version.returncode != 0:
+            return False, "Node.js is not installed or not in PATH"
+        
+        # Check TypeScript
+        tsc_version = subprocess.run(["npx", "tsc", "--version"], 
+                                  capture_output=True, 
+                                  text=True)
+        if tsc_version.returncode != 0:
+            return False, "TypeScript is not installed. Please run 'npm install -g typescript'"
+        
+        return True, "Environment OK"
+    except Exception as e:
+        return False, f"Error checking environment: {str(e)}"
+
+def create_temp_package_json():
+    """Create a temporary package.json file for Node.js execution"""
+    package_json = {
+        "name": "temp-code-execution",
+        "version": "1.0.0",
+        "type": "module",
+        "dependencies": {
+            "typescript": "^4.9.5"
+        }
+    }
+    with open("package.json", "w") as f:
+        json.dump(package_json, f)
+
+def run_javascript_code(code, is_typescript=False):
+    """Execute JavaScript or TypeScript code using Node.js"""
+    # Check environment first
+    env_ok, env_message = check_node_typescript_installation()
+    if not env_ok:
+        return f"Environment Error: {env_message}"
+    try:
+        # Create necessary files
+        create_temp_package_json()
+        
+        if is_typescript:
+            # For TypeScript, we need to compile first
+            with open("temp_code.ts", "w") as f:
+                f.write(code)
+            
+            # Compile TypeScript
+            compile_process = subprocess.run(
+                ["npx", "tsc", "temp_code.ts", "--module", "ES2020", "--target", "ES2020"],
+                capture_output=True,
+                text=True
+            )
+
+            
+            # if compile_process.returncode != 0:
+            #     return f"TypeScript Compilation Error:\n{compile_process.stderr}"
+            
+            return compile_process
+            
+            # Run compiled JavaScript
+            file_to_run = "temp_code.js"
+        else:
+            # For JavaScript, write directly to .js file
+            with open("temp_code.js", "w") as f:
+                f.write(code)
+            file_to_run = "temp_code.js"
+        
+        # Execute the code using Node.js
+        result = subprocess.run(
+            ["node", file_to_run],
+            capture_output=True,
+            text=True
+        )
+        
+        # Clean up temporary files
+        cleanup_files = ["temp_code.js", "temp_code.ts", "package.json"]
+        for file in cleanup_files:
+            if os.path.exists(file):
+                os.remove(file)
+        
+        # return result.stderr if result.stderr else result.stdout
+        return result
+    
+    except Exception as e:
+        return f"Error: {e}"
+    
+def run_rust_code(code):
+    with open('code.rs', 'w') as file:
+        file.write(code)
+    
+    compile_process = subprocess.Popen(['rustc', 'code.rs'], 
+                                     stdout=subprocess.PIPE, 
+                                     stderr=subprocess.PIPE, 
+                                     text=True)
+    compile_output, compile_errors = compile_process.communicate()
+    
+    if compile_process.returncode != 0:
+        return f"Compilation Error: {compile_errors}"
+    
+    run_process = subprocess.Popen(['./code'], 
+                                 stdout=subprocess.PIPE, 
+                                 stderr=subprocess.PIPE, 
+                                 text=True)
+    run_output, run_errors = run_process.communicate()
+    return run_output if not run_errors else run_errors
+
+
+### Parameter
+
+# Max tries
+max_iterations = 3
+
+# Reflect
+# flag = 'reflect'
+flag = "do not reflect"
+
+### Nodes
+
+
+def generate(state: GraphState):
+    """
+    Generate a code solution
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, generation
+    """
+
+    print("---GENERATING CODE SOLUTION---")
+
+    # State
+    messages = state["messages"]
+    iterations = state["iterations"]
+    error = state["error"]
+
+    question = state['messages'][-1][1]
+
+    # We have been routed back to generation with an error
+    if error == "yes":
+        messages += [
+            (
+                "user",
+                "Now, try again. Invoke the code tool to structure the output with a prefix, imports, and code block:",
+            )
+        ]
+
+    # Post-processing
+    def format_docs(docs):
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    retrieved_docs = retriever.invoke(question)
+    formated_docs = format_docs(retrieved_docs)
+    
+
+    # Solution
+    code_solution = code_gen_chain.invoke(
+        {"context": formated_docs, "messages": messages}
+    )
+    messages += [
+        (
+            "assistant",
+            f"{code_solution.prefix} \n Imports: {code_solution.imports} \n Code: {code_solution.code}",
+        )
+    ]
+
+    # Increment
+    iterations = iterations + 1
+    return {"generation": code_solution, "messages": messages, "iterations": iterations}
+
+
+def code_check(state: GraphState):
+    """
+    Check code
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, error
+    """
+
+    print("---CHECKING CODE---")
+
+    # State
+    messages = state["messages"]
+    code_solution = state["generation"]
+    iterations = state["iterations"]
+
+    # Get solution components
+    imports = code_solution.imports
+    code = code_solution.code
+    language = code_solution.language
+
+    if language.lower()=="python":
+
+
+        # Check imports
+        try:
+            exec(imports)
+        except Exception as e:
+            print("---CODE IMPORT CHECK: FAILED---")
+            error_message = [("user", f"Your solution failed the import test: {e}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+
+        # Check execution
+        try:
+            exec(imports + "\n" + code)
+        except Exception as e:
+            print("---CODE BLOCK CHECK: FAILED---")
+            error_message = [("user", f"Your solution failed the code execution test: {e}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+        
+    if language.lower()=="javascript":
+
+        full_code = imports + "\n" + code
+
+
+        result = run_javascript_code(full_code, is_typescript=False)
+
+        if result.stderr:
+            print("---JS CODE BLOCK CHECK: FAILED---")
+            print(f"This is the error:{result.stderr}")
+            error_message = [("user", f"Your javascript solution failed the code execution test: {result.stderr}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+    
+
+
+    if language.lower()=="typescript":
+
+        full_code = imports + "\n" + code
+
+
+        result = run_javascript_code(full_code, is_typescript=True)
+
+        if result.stderr:
+            print("---TS CODE BLOCK CHECK: FAILED---")
+            print(f"This is the error:{result.stderr}")
+            error_message = [("user", f"Your typesript solution failed the code execution test: {result.stderr}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+
+
+    if language.lower()=="rust":
+
+        full_code = imports + "\n" + code
+
+        with open('code.rs', 'w') as file:
+            file.write(full_code)
+        
+        compile_process = subprocess.Popen(['rustc', 'code.rs'], 
+                                        stdout=subprocess.PIPE, 
+                                        stderr=subprocess.PIPE, 
+                                        text=True)
+        compile_output, compile_errors = compile_process.communicate()
+        
+        if compile_process.stderr:
+            # return f"Compilation Error: {compile_errors}"
+            print("---RUST CODE BLOCK CHECK: COMPILATION FAILED---")
+            print(f"This is the error:{compile_process.stderr}")
+            error_message = [("user", f"Your rust solution failed the code compilation test: {compile_process.stderr}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+        
+        run_process = subprocess.Popen(['./code'], 
+                                    stdout=subprocess.PIPE, 
+                                    stderr=subprocess.PIPE, 
+                                    text=True)
+        run_output, run_errors = run_process.communicate()
+        
+
+        if run_process.stderr:
+            print("---RUST CODE BLOCK CHECK: RUN FAILED---")
+            print(f"This is the error:{run_errors}")
+            error_message = [("user", f"Your rust solution failed the code run test: {run_errors}")]
+            messages += error_message
+            return {
+                "generation": code_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+        # return run_output if not run_errors else run_errors
+        
+
+    elif language.lower() not in ["rust", "python", "typescript", "javascript"]:
+
+        # Can't test the code
+        print("---CANNOT TEST CODE: CODE NOT IN EXPECTED LANGUAGE---")
+        
+        return {
+            "generation": code_solution,
+            "messages": messages,
+            "iterations": iterations,
+            "error": "no",
+        }
+
+
+
+    # No errors
+    print("---NO CODE TEST FAILURES---")
+    return {
+        "generation": code_solution,
+        "messages": messages,
+        "iterations": iterations,
+        "error": "no",
+    }
+
+
+def reflect(state: GraphState):
+    """
+    Reflect on errors
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, generation
+    """
+
+    print("---REFLECTING ON CODE SOLUTION ERRORS---")
+
+    # State
+    messages = state["messages"]
+    iterations = state["iterations"]
+    code_solution = state["generation"]
+    question = state['messages'][-1][1]
+
+    # Prompt reflection
+
+    # Post-processing
+    def format_docs(docs):
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    retrieved_docs = retriever.invoke(question)
+    formated_docs = format_docs(retrieved_docs)
+
+    # Add reflection
+    reflections = code_gen_chain.invoke(
+        {"context": formated_docs, "messages": messages}
+    )
+    
+    messages += [("assistant", f"Here are reflections on the error: {reflections}")]
+    return {"generation": code_solution, "messages": messages, "iterations": iterations}
+
+
+### Edges
+
+
+def decide_to_finish(state: GraphState):
+    """
+    Determines whether to finish.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Next node to call
+    """
+    error = state["error"]
+    iterations = state["iterations"]
+
+    if error == "no" or iterations == max_iterations:
+        print("---DECISION: FINISH---")
+        return "end"
+    else:
+        print("---DECISION: RE-TRY SOLUTION---")
+        if flag == "reflect":
+            return "reflect"
+        else:
+            return "generate"
+        
+
+
+def get_runnable():
+    workflow = StateGraph(GraphState)
+
+    # Define the nodes
+    workflow.add_node("generate", generate)  # generation solution
+    workflow.add_node("check_code", code_check)  # check code
+    workflow.add_node("reflect", reflect)  # reflect
+
+    # Build graph
+    workflow.add_edge(START, "generate")
+    workflow.add_edge("generate", "check_code")
+    workflow.add_conditional_edges(
+        "check_code",
+        decide_to_finish,
+        {
+            "end": END,
+            "reflect": "reflect",
+            "generate": "generate",
+        },
+    )
+    workflow.add_edge("reflect", "generate")
+
+    # Remove the checkpointer for now since it's causing issues
+    code_assistant_app = workflow.compile()
+
+    #     memory = AsyncSqliteSaver.from_conn_string(":memory:")
+
+#     code_assistant_app = workflow.compile(checkpointer=memory)
+
+    return code_assistant_app
+
+# if __name__ == "__main__":
+#     graph = get_runnable()
+#     prompt = "How do I read from the solana network?"
+#     print(f'{graph.invoke({"messages": [("user", prompt)], "iterations": 0, "error": ""})}')
+

requirements.txt

@@ -0,0 +1,32 @@
+langgraph==0.2.56
+langchain-community
+langchain-groq
+langchain-anthropic
+langchain-openai
+langchain-ollama
+langchain-nomic[local]
+tiktoken 
+langchainhub 
+chromadb
+langchain-chroma
+langchain-text-splitters
+bs4
+python-dotenv
+sentence_transformers
+langchain_experimental
+matplotlib
+streamlit==1.38.0
+streamlit_ace==0.1.1
+transformers
+accelerate
+datasets>=2.16.1
+bitsandbytes==0.41.3
+peft==0.8.2
+trl==0.7.10
+wandb==0.16.3
+huggingface_hub
+nbformat
+PyGithub
+playwright
+aiosqlite==0.20.0
+langgraph-checkpoint-sqlite