Upload 4 files

Dockerfile

@@ -0,0 +1,33 @@
+# Use lightweight Python image
+FROM python:3.10-slim
+
+# Prevent Python from writing .pyc files
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Ensure logs appear immediately
+ENV PYTHONUNBUFFERED=1
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies (minimal but safe)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    curl && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Expose port used by Flask / Gunicorn
+EXPOSE 7860
+
+# Start server (production-safe)
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--workers", "1", "--timeout", "120"]

app.py

@@ -0,0 +1,218 @@
+import os
+import json
+import re
+from time import time
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# api load
+load_dotenv()
+
+app = Flask(__name__)
+
+# frontend lock so other canot use
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "https://sumit989bishnoi-crypto.github.io")
+CORS(app, origins=allowed_origins.split(","))
+
+# models
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME   = os.getenv("MODEL_NAME",   "Qwen/Qwen2.5-7B-Instruct")
+
+# api and hftoken both can pull as user request
+API_KEY = os.getenv("API_KEY") or os.getenv("HF_TOKEN")
+
+# when no api key found
+client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY) if API_KEY else None
+
+# language lmt
+SUPPORTED_LANGUAGES = [
+    "python", "javascript", "typescript", "java", "c", "cpp",
+    "csharp", "go", "rust", "php", "ruby", "swift", "kotlin", "bash"
+]
+
+# map ip
+_last_request: dict[str, float] = {}
+
+
+def is_rate_limited(ip: str) -> bool:
+    """Block the same IP if it hits us again within 2 seconds."""
+    now = time()
+    if ip in _last_request and now - _last_request[ip] < 2:
+        return True
+    _last_request[ip] = now
+    return False
+
+
+def extract_json(raw: str) -> dict | None:
+    """
+    Try to parse JSON out of the AI's raw response.
+    The model sometimes wraps output in markdown fences or adds extra prose,
+    so we strip that first, then fall back to a boundary-aware parser.
+    """
+    cleaned = re.sub(r"^```(?:json)?\s*", "", raw.strip())
+    cleaned = re.sub(r"\s*```$", "", cleaned).strip()
+
+    # fast path
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        pass
+
+    # slow path
+    # raw decode stops exactly where the JSON ends
+    try:
+        idx = cleaned.index("{")
+        decoded, _ = json.JSONDecoder().raw_decode(cleaned, idx)
+        return decoded
+    except (ValueError, json.JSONDecodeError):
+        return None
+
+
+# routes start
+
+@app.route("/")
+def index():
+    # basic info of endpoint
+    return jsonify({"name": "CodeRescue API", "version": "1.0.0", "status": "running"})
+
+
+@app.route("/health")
+def health():
+    # health check code
+    return jsonify({"status": "ok"})
+
+
+# languages support
+@app.route("/languages")
+def languages():
+    return jsonify({"languages": SUPPORTED_LANGUAGES})
+
+
+@app.route("/analyze", methods=["POST"])
+def analyze_code():
+    # rate limit
+
+    # x forwarded for is set by proxies
+    forwarded = request.headers.get("X-Forwarded-For", "")
+    ip = forwarded.split(",")[0].strip() if forwarded else (request.remote_addr or "unknown")
+
+    if is_rate_limited(ip):
+        return jsonify({
+            "error": "Too many requests. Please wait a moment.",
+            "fixed_code": "",
+            "language": ""
+        }), 429
+
+    # pre checks
+
+    if not client:
+        # to stop request here
+        return jsonify({"error": "API key not configured", "fixed_code": "", "language": ""}), 500
+
+    data = request.get_json(silent=True)
+    if not data or not data.get("code", "").strip():
+        return jsonify({"error": "No code provided"}), 400
+
+    raw_code = data["code"].strip()
+    language = data.get("language", "python").lower()
+
+    if language not in SUPPORTED_LANGUAGES:
+        return jsonify({
+            "error": f"Unsupported language '{language}'. Supported: {SUPPORTED_LANGUAGES}"
+        }), 400
+
+    # input prep
+
+    # input limit
+    warning = ""
+    if len(raw_code) > 800:
+        warning = "Code was truncated to 800 characters for processing."
+    user_code = raw_code[:800]
+
+    # call model
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            max_tokens=800,  # max token
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are an expert developer and code debugger.\n"
+                        "Return ONLY valid JSON — no markdown, no extra text.\n"
+                        "Explain briefly WHY the error happened (1-2 lines).\n"
+                        "Fixed code must be SHORT and COMPLETE.\n"
+                        "Preserve all newlines and indentation in fixed_code.\n"
+                        "Do NOT cut output mid-way.\n"
+                        "Set confidence to 'high', 'medium', or 'low' based on how certain you are.\n"
+                        "Format strictly:\n"
+                        "{\"explanation\":\"...\",\"fixed_code\":\"...\","
+                        "\"language\":\"...\",\"confidence\":\"high|medium|low\"}"
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": f"Language: {language}\n\nCode:\n{user_code}",
+                },
+            ],
+        )
+
+        raw = response.choices[0].message.content.strip()
+
+        # model returned nothing
+        if not raw:
+            return jsonify({
+                "explanation": "Empty response from AI.",
+                "fixed_code": "",
+                "language": language,
+                "confidence": "low",
+                "warning": warning
+            }), 200
+
+        # parse response
+        parsed = extract_json(raw)
+
+        # return the raw text so the user sees something
+        if not parsed:
+            return jsonify({
+                "explanation": "AI response was not clean JSON — raw output returned.",
+                "fixed_code": raw[:800],
+                "language": language,
+                "confidence": "low",
+                "warning": warning
+            }), 200
+
+        # unescape literal \n and \t that the model sometimes emits inside strings
+        fixed_code = parsed.get("fixed_code", "")
+        fixed_code = fixed_code.replace("\\n", "\n").replace("\\t", "\t")
+
+        return jsonify({
+            "explanation": parsed.get("explanation", "No explanation provided."),
+            "fixed_code":  fixed_code,
+            "language":    parsed.get("language", language),
+            "confidence":  parsed.get("confidence", "medium"),
+            "warning":     warning,
+        })
+
+    except Exception as e:
+        return jsonify({
+            "explanation": f"Server error: {str(e)}",
+            "fixed_code": "",
+            "language": language,
+            "confidence": "low",
+            "warning": warning
+        }), 500
+
+
+#donot havev to change this
+@app.route("/openenv/reset", methods=["POST"])
+@app.route("/reset",         methods=["POST"])
+def openenv_reset():
+    return jsonify({"status": "success"})
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port)

inference.py

@@ -0,0 +1,94 @@
+import os
+import json
+from openai import OpenAI
+
+# ── Config ────────────────────────────────────────────────────────────────────
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME   = os.getenv("MODEL_NAME",   "Qwen/Qwen2.5-7B-Instruct")
+API_KEY      = os.getenv("API_KEY") or os.getenv("HF_TOKEN")
+
+client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY) if API_KEY else None
+
+
+def solve(task_name: str, task_input: str) -> str:
+    print(f"[START] task={task_name}", flush=True)
+    print(f"[STEP] step=1 reward=0.5", flush=True)
+
+    if not client:
+        print(f"[END] task={task_name} score=0.1 steps=1", flush=True)
+        return "Error: API key not configured"
+
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        max_tokens=2048,
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "You are an expert developer.\n"
+                    "Return ONLY valid JSON.\n"
+                    "Explanation must be MAX 2 lines.\n"
+                    "Fixed code must be SHORT and COMPLETE.\n"
+                    "Preserve all newlines and indentation in fixed_code.\n"
+                    "Do NOT cut output.\n"
+                    "Format strictly:\n"
+                    "{\"explanation\":\"...\",\"fixed_code\":\"...\",\"language\":\"...\"}"
+                ),
+            },
+            {
+                "role": "user",
+                "content": f"Fix this code and explain the errors:\n{task_input}",
+            },
+        ],
+    )
+
+    output = response.choices[0].message.content
+    score  = grade(task_input, output)
+
+    print(f"[STEP] step=2 reward={score}", flush=True)
+    print(f"[END] task={task_name} score={score} steps=2", flush=True)
+
+    return output
+
+
+def grade(task_input: str, output: str) -> float:
+    if not output or len(output.strip()) < 5:
+        return 0.1
+
+    score = 0.5
+    try:
+        raw = output.strip().replace("```json", "").replace("```", "").strip()
+        parsed = json.loads(raw)
+        if parsed.get("explanation"):
+            score += 0.15
+        if parsed.get("fixed_code"):
+            score += 0.15
+        if parsed.get("language"):
+            score += 0.1
+    except Exception:
+        score = 0.3
+
+    return round(min(max(score, 0.1), 0.9), 2)
+
+
+# ── Tasks ─────────────────────────────────────────────────────────────────────
+TASKS = [
+    {
+        "id": "task_1",
+        "description": "Fix syntax error in Python",
+        "input": "def hello(\n    print('hello world')",
+    },
+    {
+        "id": "task_2",
+        "description": "Fix logic bug in JavaScript",
+        "input": "function add(a, b) { return a - b; }",
+    },
+    {
+        "id": "task_3",
+        "description": "Fix type error and missing await in async function",
+        "input": "async function fetchData() { let data = fetchFromAPI(); return data.json; }",
+    },
+]
+
+for task in TASKS:
+    output = solve(task["id"], task["input"])

requirements.txt

@@ -0,0 +1,6 @@
+flask
+flask-cors
+python-dotenv
+openai
+gunicorn
+requests