Rename src/streamlit_app.py to src/app.py

src/app.py

@@ -0,0 +1,197 @@
+import streamlit as st
+import json
+import time
+import plotly.graph_objects as go
+from detector import (
+    smart_chunk_text,
+    has_html_or_ai_artifacts,
+    calibrate_threshold,
+    predict_chunks_with_tau,
+    preprocess_text_for_detection,
+)
+
+st.set_page_config(page_title="AI Text Detector Pro", layout="wide", page_icon="🔍")
+
+# --- Professional CSS ---
+st.markdown("""
+<style>
+    .main-header { font-size: 2.5rem; font-weight: 700; color: #1f77b4; text-align: center; margin-bottom: 1rem; }
+    .result-card { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 2rem; border-radius: 15px; color: white; margin: 1rem 0; }
+    .ai-highlight { background-color: #ff6b6b; padding: 4px 8px; border-radius: 4px; color: white; margin: 2px; display: inline-block; }
+    .human-highlight { background-color: #51cf66; padding: 4px 8px; border-radius: 4px; color: white; margin: 2px; display: inline-block; }
+    .metric-card { background: #f8f9fa; padding: 1rem; border-radius: 10px; border-left: 4px solid #1f77b4; margin: 0.5rem 0; }
+    .feature-badge { background: #e9ecef; padding: 0.3rem 0.8rem; border-radius: 20px; font-size: 0.8rem; margin: 0.2rem; display: inline-block; }
+</style>
+""", unsafe_allow_html=True)
+
+st.markdown('<div class="main-header">🔍 AI Text Detector Pro</div>', unsafe_allow_html=True)
+st.caption("Advanced detection using ensemble methods with GPT-5 pattern recognition")
+
+# === Calibration ===
+human_calibration_texts = [
+    "This is a genuine human-written sentence for calibration purposes.",
+    "Another authentic text sample composed by a human author.",
+    "Calibrating detectors with real-world data improves reliability."
+]
+tau = calibrate_threshold(human_calibration_texts, calibration_proportion=0.05)
+
+# === Sidebar ===
+with st.sidebar:
+    st.header("Settings")
+    detection_mode = st.selectbox(
+        "Detection Mode",
+        ["Standard", "Aggressive", "Conservative"],
+        help="Standard: Balanced approach, Aggressive: Higher AI detection, Conservative: Higher human detection"
+    )
+    show_details = st.checkbox("Show Detailed Analysis", value=True)
+    enable_chunking = st.checkbox("Enable Text Chunking", value=False)
+
+# === Main Interface ===
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    text = st.text_area(
+        "Enter text to analyze:", 
+        height=250, 
+        placeholder="Paste your text here...\n\nTip: For better accuracy, provide text with at least 50 words.",
+        help="The detector works best with longer texts (100+ words)"
+    )
+
+with col2:
+    st.info("**💡 Detection Features:**")
+    st.write("• GPT-5 pattern recognition")
+    st.write("• Statistical analysis")
+    st.write("• Sentence structure evaluation")
+    st.write("• Repetition detection")
+    st.write("• HTML/artifact detection")
+
+if st.button("🚀 Analyze Text", type="primary", use_container_width=True):
+    if not text.strip():
+        st.error("⚠️ Please enter some text to analyze!")
+    else:
+        with st.spinner("🔄 Analyzing text with advanced detection..."):
+            time.sleep(1)
+
+            # Preprocess
+            clean_text = preprocess_text_for_detection(text)
+
+            if has_html_or_ai_artifacts(clean_text):
+                st.markdown("""
+                <div class="result-card">
+                    <h2>🔴 AI-Generated Content Detected</h2>
+                    <p>HTML tags or AI artifacts found in the text.</p>
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                # Process text
+                if enable_chunking and len(clean_text.split()) > 50:
+                    chunks = smart_chunk_text(clean_text)
+                else:
+                    chunks = [clean_text]
+                
+                results = predict_chunks_with_tau(chunks, tau)
+
+                # Weighted scoring
+                total_length = sum(len(c["text"]) for c in results)
+                ai_weighted = sum(len(c["text"]) * c["score"] for c in results)
+                human_weighted = total_length - ai_weighted
+
+                ai_percentage = round((ai_weighted / total_length) * 100, 1) if total_length else 0
+                human_percentage = round(100 - ai_percentage, 1)
+
+                # Apply detection mode adjustments
+                if detection_mode == "Aggressive":
+                    ai_percentage = min(ai_percentage * 1.2, 100)
+                    human_percentage = 100 - ai_percentage
+                elif detection_mode == "Conservative":
+                    ai_percentage = ai_percentage * 0.8
+                    human_percentage = 100 - ai_percentage
+
+                # Result text
+                if ai_percentage >= 70:
+                    result_emoji, result_text = "🔴", "HIGH AI PROBABILITY"
+                elif ai_percentage >= 40:
+                    result_emoji, result_text = "🟡", "MIXED CONTENT"
+                else:
+                    result_emoji, result_text = "🟢", "LIKELY HUMAN"
+
+                # Display card
+                st.markdown(f"""
+                <div class="result-card">
+                    <h2>{result_emoji} {result_text}</h2>
+                    <div style="display: flex; justify-content: space-between; align-items: center;">
+                        <div>
+                            <h3>AI: {ai_percentage}%</h3>
+                            <h3>Human: {human_percentage}%</h3>
+                        </div>
+                        <div style="font-size: 3rem;">{result_emoji}</div>
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+
+                # Metrics
+                col1, col2, col3 = st.columns(3)
+                with col1: st.metric("AI Probability", f"{ai_percentage}%")
+                with col2: st.metric("Human Probability", f"{human_percentage}%")
+                with col3: st.metric("Confidence", "High" if abs(ai_percentage - human_percentage) > 30 else "Medium")
+
+                st.progress(ai_percentage / 100)
+
+                # Highlighted output
+                st.subheader("📊 Text Analysis")
+                html_output = ""
+                for result in results:
+                    css_class = "ai-highlight" if result["type"] == "AI" else "human-highlight"
+                    html_output += f'<span class="{css_class}" title="Score: {result["score"]:.3f}">{result["text"]}</span> '
+                st.markdown(f'<div style="line-height: 2.5;">{html_output}</div>', unsafe_allow_html=True)
+
+                # Detailed analysis
+                if show_details:
+                    with st.expander("🔍 Detailed Analysis Report", expanded=True):
+                        tab1, tab2, tab3 = st.tabs(["Feature Analysis", "Chunk Details", "Visualization"])
+                        
+                        with tab1:
+                            st.write("**Feature Scores:** Under development.")
+                        with tab2:
+                            for i, result in enumerate(results):
+                                st.write(f"**Chunk {i+1}:** ({result['type']} - Score: {result['score']:.3f})")
+                                st.write(result["text"])
+                                st.divider()
+                        with tab3:
+                            if len(results) > 1:
+                                scores = [r["score"] for r in results]
+                                fig = go.Figure()
+                                fig.add_trace(go.Scatter(
+                                    x=list(range(1, len(scores) + 1)),
+                                    y=scores,
+                                    mode='lines+markers',
+                                    name='AI Probability',
+                                    line=dict(color='red', width=3)
+                                ))
+                                fig.update_layout(
+                                    title="AI Probability Across Text Chunks",
+                                    xaxis_title="Chunk Number",
+                                    yaxis_title="AI Probability",
+                                    showlegend=True
+                                )
+                                st.plotly_chart(fig, use_container_width=True)
+
+                # Download report
+                st.download_button(
+                    "📥 Download Full Report",
+                    data=json.dumps({
+                        "overview": {
+                            "ai_percentage": ai_percentage,
+                            "human_percentage": human_percentage,
+                            "result": result_text,
+                            "detection_mode": detection_mode
+                        },
+                        "detailed_results": results
+                    }, indent=2),
+                    file_name=f"ai_detection_report_{int(time.time())}.json",
+                    mime="application/json",
+                )
+
+# Footer
+st.markdown("---")
+st.caption("🔬 **AI Text Detector Pro** v2.0 | Enhanced with GPT-5 pattern recognition and statistical analysis")

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))