Upload 5 files

controllers/auth_controller.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, Request
+from log import log
+
+router = APIRouter()
+
+@router.post("/login")
+async def login(request: Request):
+    data = await request.json()
+    username = data.get("username")
+    password = data.get("password")
+    if not username or not password:
+        return {"error": "Username and password required."}
+    
+    # Buraya hash+salt şifre kontrolü eklenecek (şimdilik basit log)
+    log(f"🔐 Login attempt for user: {username}")
+    return {"message": f"User {username} logged in (mock)."}

controllers/config_controller.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+import threading
+from service_config import ServiceConfig
+from log import log
+
+router = APIRouter()
+service_config = ServiceConfig()
+
+@router.post("/reload")
+def reload_config():
+    def background_reload():
+        try:
+            service_config.load()
+            log("✅ Service config reloaded successfully.")
+        except Exception as e:
+            log(f"❌ Error reloading config: {e}")
+    threading.Thread(target=background_reload, daemon=True).start()
+    return {"status": "accepted", "message": "Config reload started in background."}

controllers/init.py

@@ -0,0 +1 @@
+# Boş init dosyası, importlar için

controllers/project_controller.py

@@ -0,0 +1,107 @@
+from fastapi import APIRouter, Request, Header
+from session import SessionStore
+from service_config import ServiceConfig
+from prompt_engine import PromptEngine
+from llm_connector import LLMConnector
+from api_connector import APIConnector
+from validation_engine import ValidationEngine
+from log import log
+import traceback
+
+router = APIRouter()
+
+# Core bileşenler
+service_config = ServiceConfig()
+service_config.load()
+session_store = SessionStore()
+prompt_engine = PromptEngine(service_config)
+llm_connector = LLMConnector(service_config)
+api_connector = APIConnector(service_config)
+validation_engine = ValidationEngine()
+
+@router.post("/start_chat")
+def start_chat(request: Request):
+    project_name = request.query_params.get("project_name")
+    if not project_name:
+        return {"error": "Missing project_name parameter."}
+    session = session_store.create_session(project_name)
+    return {"session_id": session.session_id}
+
+@router.post("/chat")
+async def chat(request: Request, x_session_id: str = Header(None)):
+    if not x_session_id:
+        return {"error": "Missing X-Session-ID header."}
+    session = session_store.get_session(x_session_id)
+    if not session:
+        return {"error": "Invalid or expired session."}
+    try:
+        body = await request.json()
+        user_input = body.get("user_input", "").strip()
+        if not user_input:
+            return {"error": "Empty user input."}
+        session.chat_history.append({"role": "user", "content": user_input})
+        project_name = session.project_name
+
+        if session.state == "intent_detection":
+            prompt = prompt_engine.build_intent_prompt(project_name)
+            llm_response = llm_connector.call_spark(project_name, prompt, session.chat_history)
+            if llm_response is None:
+                return {"error": "Failed to get intent detection result."}
+            intent = llm_response.get("intent")
+            params = llm_response.get("params", {})
+            missing = llm_response.get("missing", [])
+            session.last_intent = intent
+            session.variables.update(params)
+            session.awaiting_parameters = missing
+            if missing:
+                session.state = "parameter_extraction"
+                return {"response": f"Please provide: {', '.join(missing)}"}
+            session.state = "validation"
+
+        if session.state == "parameter_extraction":
+            prompt = prompt_engine.build_parameter_prompt(project_name, session.last_intent, session.awaiting_parameters)
+            llm_response = llm_connector.call_spark(project_name, prompt, session.chat_history)
+            if llm_response is None:
+                return {"error": "Failed to extract parameters."}
+            params = llm_response.get("params", {})
+            missing = llm_response.get("missing", [])
+            session.variables.update(params)
+            session.awaiting_parameters = missing
+            if missing:
+                return {"response": f"Please provide: {', '.join(missing)}"}
+            session.state = "validation"
+
+        if session.state == "validation":
+            intent_def = next((i for i in service_config.get_project_intents(project_name) if i["name"] == session.last_intent), None)
+            if not intent_def:
+                return {"error": f"Intent definition not found: {session.last_intent}"}
+            is_valid, errors = validation_engine.validate_parameters(intent_def, session.variables)
+            if not is_valid:
+                return {"response": " ".join(errors)}
+            session.state = "api_call"
+
+        if session.state == "api_call":
+            intent_def = next((i for i in service_config.get_project_intents(project_name) if i["name"] == session.last_intent), None)
+            api_response = api_connector.call_api(intent_def, session)
+            if "fallback" in api_response:
+                return {"response": api_response["fallback"]}
+            session.state = "humanization"
+            session.variables["api_result"] = api_response
+
+        if session.state == "humanization":
+            prompt = prompt_engine.build_humanization_prompt(project_name, session.last_intent)
+            chat_history = [{"role": "system", "content": str(session.variables["api_result"])}]
+            humanized_response = llm_connector.call_spark(project_name, prompt, chat_history)
+            if humanized_response is None:
+                return {"error": "Failed to humanize response."}
+            session.chat_history.append({"role": "assistant", "content": humanized_response.get("answer")})
+            session.state = "intent_detection"
+            session.last_intent = None
+            session.variables = {}
+            session.awaiting_parameters = []
+            return {"response": humanized_response.get("answer")}
+
+    except Exception as e:
+        log(f"❌ Error in chat: {e}")
+        traceback.print_exc()
+        return {"error": str(e)}

controllers/test_controller.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+from log import log
+
+router = APIRouter()
+
+@router.post("/run_tests")
+def run_tests():
+    log("🚦 /run_tests endpoint called. (Test runner needs to be implemented.)")
+    return {"status": "not_implemented", "message": "Test runner is not yet implemented."}