Update app.py

app.py

@@ -1,63 +1,87 @@
 import streamlit as st
-from transformers import AutoTokenizer
-from optimum.intel import OVModelForCausalLM
-import re
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
 
-# --- Setup ---
-MODEL_ID = "Qwen/Qwen2.5-Coder-0.5B-Instruct"
+# --- CONFIGURATION ---
+MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
+DEVICE = "cpu"
 
-st.set_page_config(page_title="Code Validator & Fixer", layout="wide")
+st.set_page_config(page_title="Jenkins Pipeline Architect", layout="wide")
 
+# --- MODEL LOADING (Cached for Speed) ---
 @st.cache_resource
-def load_engine():
+def load_model():
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-    # export=True will convert the model to OpenVINO IR on first run
-    model = OVModelForCausalLM.from_pretrained(
-        MODEL_ID, 
-        export=True, 
-        device="CPU", 
-        load_in_8bit=True
-    )
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(DEVICE)
     return tokenizer, model
 
-tokenizer, model = load_engine()
+tokenizer, model = load_model()
 
-# --- UI ---
-st.title("🏗️ Smart Code Validator")
-st.write("Analyzes and fixes your code using Qwen2.5-Coder (CPU-Optimized)")
+# --- UI LOGIC ---
+st.title("🚀 Jenkins Pipeline Architect")
+st.caption("Powered by SmolLM2-135M (CPU Optimized)")
 
-col_input, col_output = st.columns(2)
+with st.sidebar:
+    st.header("Pipeline Configuration")
+    project_type = st.selectbox("Project Type", ["Node.js", "Python", "Java/Maven", "Docker"])
+    agent_type = st.text_input("Agent Label", value="any")
+    
+    st.subheader("Stages")
+    do_test = st.checkbox("Include Unit Tests", value=True)
+    do_lint = st.checkbox("Include Linting", value=False)
+    do_deploy = st.checkbox("Include Deployment", value=True)
+    
+    env_vars = st.text_area("Env Vars (Key=Value)", placeholder="DB_HOST=localhost")
 
-with col_input:
-    user_code = st.text_area("Paste your code here:", height=400, placeholder="pipeline { ... }")
-    run_btn = st.button("Validate & Fix", use_container_width=True)
+# --- GENERATION LOGIC ---
+def generate_pipeline(config):
+    # Precise system prompt for a small model
+    prompt = f"""Generate a Jenkinsfile (Declarative Pipeline) for a {config['type']} project.
+    - Agent: {config['agent']}
+    - Options: {config['options']}
+    - Stages: {config['stages']}
+    Return ONLY the Groovy code. No explanations."""
 
-if run_btn and user_code:
-    # 1. Prepare Request
-    messages = [
-        {"role": "system", "content": "You are a senior developer. First, explain errors briefly. Second, provide the full corrected code inside a ```groovy block."},
-        {"role": "user", "content": f"Review and fix this code:\n{user_code}"}
-    ]
+    messages = [{"role": "user", "content": prompt}]
+    input_text = tokenizer.apply_chat_template(messages, tokenize=False)
+    inputs = tokenizer.encode(input_text, return_tensors="pt").to(DEVICE)
     
-    prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = tokenizer(prompt, return_tensors="pt")
+    outputs = model.generate(
+        inputs, 
+        max_new_tokens=500, 
+        temperature=0.1, # Keep it deterministic for code
+        do_sample=False
+    )
+    return tokenizer.decode(outputs[0], skip_special_tokens=True).split("assistant")[-1].strip()
+
+# --- MAIN VIEW ---
+col1, col2 = st.columns([1, 1])
 
-    # 2. Generate
-    with st.spinner("Analyzing on CPU..."):
-        tokens = model.generate(**inputs, max_new_tokens=1024, do_sample=False)
-        response = tokenizer.decode(tokens[0][len(inputs[0]):], skip_special_tokens=True)
+with col1:
+    st.markdown("### Preview Requirements")
+    st.info(f"Building a pipeline for **{project_type}** running on **{agent_type}**.")
     
-    # 3. Extract Fixed Code
-    code_match = re.search(r"```(?:\w+)?\n([\s\S]*?)```", response)
-    fixed_code = code_match.group(1) if code_match else None
-    explanation = re.sub(r"```[\s\S]*?```", "", response).strip()
-
-    with col_output:
-        st.subheader("Analysis")
-        st.info(explanation if explanation else "Code looks good! Here is the optimized version:")
+    if st.button("Generate Jenkinsfile", type="primary"):
+        stages = ["Build"]
+        if do_test: stages.append("Test")
+        if do_lint: stages.append("Lint")
+        if do_deploy: stages.append("Deploy")
+        
+        config = {
+            "type": project_type,
+            "agent": agent_type,
+            "stages": ", ".join(stages),
+            "options": env_vars
+        }
         
-        if fixed_code:
-            st.subheader("Corrected Code")
-            st.code(fixed_code)
-            st.download_button("Download Fixed File", fixed_code, file_name="fixed_code.groovy")
+        with st.spinner("Writing Groovy..."):
+            pipeline_code = generate_pipeline(config)
+            st.session_state.pipeline = pipeline_code
 
+with col2:
+    st.markdown("### Generated Jenkinsfile")
+    if "pipeline" in st.session_state:
+        st.code(st.session_state.pipeline, language="groovy")
+        st.download_button("Download Jenkinsfile", st.session_state.pipeline, file_name="Jenkinsfile")
+    else:
+        st.warning("Configure settings and click generate.")