chore: 将后端移动到 api/ 目录，准备合并为单仓库

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

api/prompt/admin.py

@@ -0,0 +1,15 @@
+from django.contrib import admin
+from .models import Conversation, Message
+
+
+class MessageInline(admin.TabularInline):
+    model = Message
+    extra = 0
+    readonly_fields = ("role", "content", "code_html", "code_css", "code_js", "created")
+
+
+@admin.register(Conversation)
+class ConversationAdmin(admin.ModelAdmin):
+    list_display = ("user", "task", "is_active", "created")
+    list_filter = ("is_active",)
+    inlines = [MessageInline]

api/prompt/api.py

@@ -0,0 +1,193 @@
+import threading
+from typing import List, Optional
+from uuid import UUID
+from ninja import Router
+from ninja.errors import HttpError
+from django.shortcuts import get_object_or_404
+from django.contrib.auth.decorators import login_required
+
+from django.db.models import Count, Prefetch
+from .models import Conversation, Message
+from .utils import get_preceding_user_message
+from .schemas import ConversationOut, MessageOut, PromptHistoryItemOut
+from account.models import RoleChoices
+
+router = Router()
+
+
+@router.get("/conversations/", response=List[ConversationOut])
+@login_required
+def list_conversations(request, task_id: int = None, user_id: int = None):
+    convs = Conversation.objects.select_related("user", "task").annotate(
+        msg_count=Count("messages")
+    )
+    # Normal users can only see their own
+    if request.user.role == "normal":
+        convs = convs.filter(user=request.user)
+    elif user_id:
+        convs = convs.filter(user_id=user_id)
+    if task_id:
+        convs = convs.filter(task_id=task_id)
+    convs = convs.order_by("-msg_count", "-created")
+    return [ConversationOut.from_conv(c) for c in convs]
+
+
+@router.get("/conversations/{conversation_id}/messages/", response=List[MessageOut])
+@login_required
+def list_messages(request, conversation_id: UUID):
+    conv = get_object_or_404(Conversation, id=conversation_id)
+    # Normal users can only see their own
+    if request.user.role == "normal" and conv.user != request.user:
+        return []
+    messages = conv.messages.all()
+    return [
+        {
+            "id": m.id,
+            "role": m.role,
+            "source": m.source,
+            "content": m.content,
+            "code_html": m.code_html,
+            "code_css": m.code_css,
+            "code_js": m.code_js,
+            "prompt_level": m.prompt_level,
+            "created": m.created.isoformat(),
+        }
+        for m in messages
+    ]
+
+
+@router.get("/history/{task_id}", response=List[PromptHistoryItemOut])
+@login_required
+def list_prompt_history(request, task_id: int):
+    """
+    获取当前用户在某任务下的历史对话轮次。
+
+    只返回用户提示词和后一条 assistant 消息中的页面代码，用于前端渲染缩略图。
+    """
+    conversations = Conversation.objects.filter(
+        user=request.user,
+        task_id=task_id,
+    ).prefetch_related(
+        Prefetch("messages", queryset=Message.objects.order_by("created", "id"))
+    )
+
+    items = []
+    for conv in conversations:
+        messages = list(conv.messages.all())
+        for idx, user_msg in enumerate(messages):
+            if user_msg.role != "user":
+                continue
+
+            assistant_msg = None
+            for reply in messages[idx + 1:]:
+                if reply.role == "user":
+                    break
+                if reply.role == "assistant":
+                    assistant_msg = reply
+                    break
+
+            if not assistant_msg:
+                continue
+
+            items.append(
+                (
+                    (user_msg.created, user_msg.id),
+                    {
+                        "user_message_id": user_msg.id,
+                        "assistant_message_id": assistant_msg.id,
+                        "submission_id": assistant_msg.submission_id,
+                        "source": user_msg.source,
+                        "prompt": user_msg.content,
+                        "prompt_level": user_msg.prompt_level,
+                        "code_html": assistant_msg.code_html,
+                        "code_css": assistant_msg.code_css,
+                        "code_js": assistant_msg.code_js,
+                        "created": user_msg.created.isoformat(),
+                    },
+                )
+            )
+
+    return [item for _, item in sorted(items, key=lambda row: row[0])]
+
+
+@router.post("/conversations/{conversation_id}/classify")
+@login_required
+def classify_conversation(request, conversation_id: UUID, force: bool = False):
+    """
+    对对话中所有用户消息进行层级分类（仅管理员和超级管理员可操作，异步执行）
+    """
+    if request.user.role not in (RoleChoices.SUPER, RoleChoices.ADMIN):
+        raise HttpError(403, "没有权限")
+
+    get_object_or_404(Conversation, id=conversation_id)
+
+    from submission.classifier import classify_conversation_messages
+    threading.Thread(
+        target=classify_conversation_messages,
+        args=(conversation_id,),
+        kwargs={"force": force},
+        daemon=True,
+    ).start()
+
+    return {"message": "开始分类"}
+
+
+@router.post("/classify-batch")
+@login_required
+def classify_batch(request, task_id: Optional[int] = None, force: bool = False):
+    """
+    批量分类所有（或指定任务）对话的用户消息层级（仅管理员和超级管理员，异步执行）
+    """
+    if request.user.role not in (RoleChoices.SUPER, RoleChoices.ADMIN):
+        raise HttpError(403, "没有权限")
+
+    qs = Message.objects.filter(role="user")
+    if task_id:
+        qs = qs.filter(conversation__task_id=task_id)
+    if not force:
+        qs = qs.filter(prompt_level__isnull=True)
+
+    ids = list(qs.values_list("id", flat=True))
+
+    from submission.classifier import classify_messages_batch
+    threading.Thread(target=classify_messages_batch, args=(ids,), daemon=True).start()
+
+    return {"message": f"开始分类 {len(ids)} 条消息", "count": len(ids)}
+
+
+@router.delete("/messages/{message_id}/pair")
+@login_required
+def delete_message_pair(request, message_id: int):
+    """
+    Delete a message pair (assistant message + preceding user message) and
+    any linked submission. Only the conversation owner can do this.
+    """
+    asst_msg = get_object_or_404(Message, id=message_id, role="assistant")
+
+    if asst_msg.conversation.user != request.user and request.user.role != RoleChoices.SUPER:
+        raise HttpError(403, "只能删除自己的消息")
+
+    if asst_msg.submission_id and request.user.role != RoleChoices.SUPER:
+        from submission.models import Rating, SubmissionAward
+        has_ratings = Rating.objects.filter(submission_id=asst_msg.submission_id).exists()
+        has_awards = SubmissionAward.objects.filter(submission_id=asst_msg.submission_id).exists()
+        if has_ratings or has_awards:
+            raise HttpError(400, "该消息关联的提交已被评分或获奖，无法删除")
+
+    # Find the preceding user message
+    user_msg = get_preceding_user_message(asst_msg)
+
+    # Delete messages first, then submission
+    submission_id = asst_msg.submission_id  # capture before deletion nulls it
+
+    if user_msg:
+        user_msg.delete()
+    asst_msg.delete()
+
+    submission_deleted = False
+    if submission_id:
+        from submission.models import Submission as SubmissionModel
+        SubmissionModel.objects.filter(id=submission_id).delete()
+        submission_deleted = True
+
+    return {"deleted": True, "submission_deleted": submission_deleted}

api/prompt/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class PromptConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "prompt"
+    verbose_name = "Prompt"

api/prompt/consumers.py

@@ -0,0 +1,219 @@
+import json
+from channels.generic.websocket import AsyncWebsocketConsumer
+from channels.db import database_sync_to_async
+from .models import Message
+from .utils import can_access_task, get_or_create_active_conversation
+from .llm import stream_chat, extract_code, stream_guidance, parse_guidance_response
+
+
+class PromptConsumer(AsyncWebsocketConsumer):
+    async def connect(self):
+        self.user = self.scope["user"]
+        if self.user.is_anonymous:
+            await self.close()
+            return
+
+        self.task_id = int(self.scope["url_route"]["kwargs"]["task_id"])
+        if not await self.check_access():
+            await self.close()
+            return
+
+        self.current_user_message = None
+        await self.accept()
+
+        self.conversation = await self.get_or_create_conversation()
+        history = await self.get_history()
+        await self.send(text_data=json.dumps({
+            "type": "init",
+            "conversation_id": str(self.conversation.id),
+            "messages": history,
+        }))
+
+    async def disconnect(self, close_code):
+        if self.current_user_message:
+            await self.delete_message(self.current_user_message)
+            self.current_user_message = None
+
+    async def receive(self, text_data):
+        data = json.loads(text_data)
+        msg_type = data.get("type", "message")
+
+        if msg_type == "new_conversation":
+            return
+
+        prompt = data.get("content", "").strip()
+        model = data.get("model", "")
+        if not prompt:
+            return
+
+        self.current_user_message = await self.save_message("user", prompt)
+
+        try:
+            history = await self.get_history_for_llm()
+
+            full_response = ""
+            try:
+                async for chunk in stream_chat(history, model=model):
+                    full_response += chunk
+                    await self.send(text_data=json.dumps({
+                        "type": "stream",
+                        "content": chunk,
+                    }))
+            except Exception as e:
+                await self.send(text_data=json.dumps({
+                    "type": "error",
+                    "content": f"AI 服务出错：{str(e)}",
+                }))
+                return
+
+            code = extract_code(full_response)
+            assistant_msg = await self.save_message("assistant", full_response, code)
+            self.current_user_message = None
+
+            await self.send(text_data=json.dumps({
+                "type": "complete",
+                "code": code,
+                "message_id": assistant_msg.id,
+            }))
+
+        finally:
+            if self.current_user_message:
+                await self.delete_message(self.current_user_message)
+                self.current_user_message = None
+
+    @database_sync_to_async
+    def check_access(self):
+        return can_access_task(self.user, self.task_id)
+
+    @database_sync_to_async
+    def get_or_create_conversation(self):
+        return get_or_create_active_conversation(self.user, self.task_id)
+
+    @database_sync_to_async
+    def delete_message(self, message):
+        message.delete()
+
+    @database_sync_to_async
+    def save_message(self, role, content, code=None):
+        return Message.objects.create(
+            conversation=self.conversation,
+            role=role,
+            content=content,
+            code_html=code.get("html") if code else None,
+            code_css=code.get("css") if code else None,
+            code_js=code.get("js") if code else None,
+        )
+
+    @database_sync_to_async
+    def get_history(self):
+        messages = self.conversation.messages.filter(source="conversation")
+        return [
+            {
+                "id": m.id,
+                "role": m.role,
+                "content": m.content,
+                "code": {
+                    "html": m.code_html,
+                    "css": m.code_css,
+                    "js": m.code_js,
+                } if m.role == "assistant" else None,
+                "submitted": m.submission_id is not None if m.role == "assistant" else None,
+                "created": m.created.isoformat(),
+            }
+            for m in messages
+        ]
+
+    @database_sync_to_async
+    def get_history_for_llm(self):
+        messages = self.conversation.messages.filter(source="conversation")
+        return [{"role": m.role, "content": m.content} for m in messages]
+
+
+class GuidanceConsumer(AsyncWebsocketConsumer):
+    async def connect(self):
+        self.user = self.scope["user"]
+        if self.user.is_anonymous:
+            await self.close()
+            return
+
+        self.task_id = int(self.scope["url_route"]["kwargs"]["task_id"])
+        if not await self.check_access():
+            await self.close()
+            return
+
+        self.current_user_message = None
+        self.session_messages = []
+        await self.accept()
+
+        self.conversation = await self.get_or_create_conversation()
+        await self.send(text_data=json.dumps({"type": "init", "messages": []}))
+
+    async def disconnect(self, close_code):
+        if self.current_user_message:
+            await self.delete_message(self.current_user_message)
+            self.current_user_message = None
+
+    async def receive(self, text_data):
+        data = json.loads(text_data)
+        prompt = data.get("content", "").strip()
+        if not prompt:
+            return
+
+        self.current_user_message = await self.save_message("user", prompt)
+        self.session_messages.append({"role": "user", "content": prompt})
+
+        try:
+            full_response = ""
+            try:
+                async for chunk in stream_guidance(self.session_messages):
+                    full_response += chunk
+                    await self.send(text_data=json.dumps({
+                        "type": "stream",
+                        "content": chunk,
+                    }))
+            except Exception as e:
+                await self.send(text_data=json.dumps({
+                    "type": "error",
+                    "content": f"AI 服务出错：{str(e)}",
+                }))
+                return
+
+            clean_response, is_ready = parse_guidance_response(full_response)
+            self.session_messages.append({
+                "role": "assistant",
+                "content": clean_response,
+            })
+            assistant_msg = await self.save_message("assistant", clean_response)
+            self.current_user_message = None
+
+            await self.send(text_data=json.dumps({
+                "type": "complete",
+                "message_id": assistant_msg.id,
+                "is_ready": is_ready,
+            }))
+
+        finally:
+            if self.current_user_message:
+                await self.delete_message(self.current_user_message)
+                self.current_user_message = None
+
+    @database_sync_to_async
+    def check_access(self):
+        return can_access_task(self.user, self.task_id)
+
+    @database_sync_to_async
+    def get_or_create_conversation(self):
+        return get_or_create_active_conversation(self.user, self.task_id)
+
+    @database_sync_to_async
+    def delete_message(self, message):
+        message.delete()
+
+    @database_sync_to_async
+    def save_message(self, role, content):
+        return Message.objects.create(
+            conversation=self.conversation,
+            role=role,
+            source="guidance",
+            content=content,
+        )

api/prompt/llm.py

@@ -0,0 +1,171 @@
+import re
+from django.conf import settings
+from openai import AsyncOpenAI
+
+
+SYSTEM_PROMPT = """你是一个网页生成助手。根据用户的需求描述，生成网页代码。
+
+规则：
+1. 使用一个 ```html 代码块返回所有代码
+2. HTML 代码只需要 body 内的内容，不需要完整的 HTML 文档结构
+3. CSS 样式写在 <style> 标签内，JavaScript 写在 <script> 标签内，都放在代码块里
+4. 用中文回复，先简要说明你做了什么，然后给出代码
+5. 在已有代码基础上修改时，返回完整的修改后代码，不要只返回片段
+6. 由于任何外部链接都被屏蔽，使用纯 HTML、CSS 和 JS 实现功能，不要依赖外部库
+
+输出格式示例（必须严格遵守，只用一个代码块）：
+
+好的，我为你创建了一个点击按钮变色的示例。
+
+```html
+<style>
+button { padding: 8px 16px; }
+</style>
+
+<button id="btn">点击我</button>
+
+<script>
+document.getElementById('btn').onclick = function() {
+  this.style.background = 'red';
+};
+</script>
+```"""
+
+GUIDANCE_SYSTEM_PROMPT = """你是一个提示词写作教练，帮助学生写出清晰、具体的网页需求描述。
+
+判断标准——满足以下条件视为"够好"：
+- 有明确主题（例如：登录页、计时器、商品卡片列表）
+- 至少包含以下一项具体描述：颜色/布局/风格、交互行为（按钮点击、动画等）、页面内容（文字、数量、图标）
+
+判断为"不够好"的典型情况：
+- 目标太泛，如"做一个好看的页面"
+- 只有主题，完全没有任何视觉、交互或内容描述
+
+规则：
+1. 如果提示词不够好，用 1-2 个启发性问题引导学生补充细节，不要直接给出答案
+2. 如果提示词已经够好，以 [READY] 开头回复，简短夸奖学生并说明可以生成了
+3. 用中文回复，语气鼓励，简洁明了
+4. 使用 Markdown 语法高亮关键词，优先突出 **主题**、**视觉**、**交互**、**内容**、**可以生成** 等重点
+5. 如果回复以 [READY] 开头，[READY] 不要加粗，必须保持原始文本
+6. 不要生成任何代码"""
+
+DEFAULT_MODEL = "deepseek-v4-flash"
+DEEPSEEK_THINKING_MODEL = "deepseek-v4-flash-thinking"
+MODEL_ALIASES = {
+    DEEPSEEK_THINKING_MODEL: DEFAULT_MODEL,
+}
+NON_THINKING_MODELS = {"deepseek-v4-flash"}
+NON_THINKING_EXTRA_BODY = {"thinking": {"type": "disabled"}}
+
+# Models served by the ARK (Volcengine) endpoint
+ARK_MODELS = {"doubao-seed-2-0-lite-260215"}
+
+
+def _get_client(model: str) -> tuple[AsyncOpenAI, str]:
+    """Return (client, model_id) for the given model name."""
+    requested_model = model or DEFAULT_MODEL
+    resolved_model = MODEL_ALIASES.get(requested_model, requested_model)
+    if resolved_model in ARK_MODELS:
+        return (
+            AsyncOpenAI(
+                api_key=settings.ARK_API_KEY,
+                base_url=settings.ARK_BASE_URL,
+                timeout=120.0,
+            ),
+            resolved_model,
+        )
+    return (
+        AsyncOpenAI(
+            api_key=settings.LLM_API_KEY,
+            base_url=settings.LLM_BASE_URL,
+            timeout=120.0,
+        ),
+        resolved_model,
+    )
+
+
+def _should_disable_thinking(requested_model: str, resolved_model: str) -> bool:
+    return (
+        resolved_model in NON_THINKING_MODELS
+        and requested_model not in MODEL_ALIASES
+    )
+
+
+def _chat_completion_kwargs(
+    requested_model: str,
+    resolved_model: str,
+    messages: list[dict],
+    stream: bool,
+) -> dict:
+    kwargs = {
+        "model": resolved_model,
+        "messages": messages,
+        "stream": stream,
+    }
+    if _should_disable_thinking(requested_model, resolved_model):
+        kwargs["extra_body"] = NON_THINKING_EXTRA_BODY
+    return kwargs
+
+
+async def _stream_completion(messages: list[dict], model: str = ""):
+    client, resolved_model = _get_client(model)
+    requested_model = model or DEFAULT_MODEL
+    async with client as c:
+        stream = await c.chat.completions.create(
+            **_chat_completion_kwargs(requested_model, resolved_model, messages, stream=True),
+        )
+        async for chunk in stream:
+            delta = chunk.choices[0].delta
+            if delta.content:
+                yield delta.content
+
+
+async def stream_chat(history: list[dict], model: str = ""):
+    """Stream chat completion from the LLM. Yields content chunks."""
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}, *history]
+    async for chunk in _stream_completion(messages, model):
+        yield chunk
+
+
+def extract_code(text: str) -> dict:
+    """Extract code from AI response. Supports single HTML block (new) or separate html/css/js blocks (legacy)."""
+    result = {"html": None, "css": None, "js": None}
+    pattern = r"```(html|css|js|javascript|typescript|ts|jsx|tsx)\s*\n(.*?)```"
+    matches = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
+    for lang, code in matches:
+        lang = lang.lower()
+        if lang in ("javascript", "typescript", "ts", "jsx", "tsx"):
+            lang = "js"
+        if lang in result and result[lang] is None:
+            result[lang] = code.strip()
+
+    # Single HTML block: extract <style>/<script> contents and strip them from html
+    if result["html"] and result["css"] is None and result["js"] is None:
+        html = result["html"]
+
+        style_match = re.search(r"<style[^>]*>(.*?)</style>", html, re.DOTALL | re.IGNORECASE)
+        if style_match:
+            result["css"] = style_match.group(1).strip()
+            html = re.sub(r"<style[^>]*>.*?</style>", "", html, flags=re.DOTALL | re.IGNORECASE)
+
+        script_match = re.search(r"<script[^>]*>(.*?)</script>", html, re.DOTALL | re.IGNORECASE)
+        if script_match:
+            result["js"] = script_match.group(1).strip()
+            html = re.sub(r"<script[^>]*>.*?</script>", "", html, flags=re.DOTALL | re.IGNORECASE)
+
+        result["html"] = html.strip()
+
+    return result
+
+
+def parse_guidance_response(full_response: str) -> tuple[str, bool]:
+    if full_response.startswith("[READY]"):
+        return full_response[len("[READY]"):].lstrip("\n"), True
+    return full_response, False
+
+
+async def stream_guidance(history: list[dict]):
+    """Stream guidance coaching response. Yields content chunks."""
+    messages = [{"role": "system", "content": GUIDANCE_SYSTEM_PROMPT}, *history]
+    async for chunk in _stream_completion(messages):
+        yield chunk

api/prompt/migrations/0001_initial.py

@@ -0,0 +1,50 @@
+# Generated by Django 6.0.1 on 2026-03-04 11:01
+
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('task', '0005_alter_task_options_alter_task_display_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Conversation',
+            fields=[
+                ('created', django_extensions.db.fields.CreationDateTimeField(auto_now_add=True, verbose_name='created')),
+                ('modified', django_extensions.db.fields.ModificationDateTimeField(auto_now=True, verbose_name='modified')),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('is_active', models.BooleanField(default=True, verbose_name='是否活跃')),
+                ('task', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='conversations', to='task.task')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='conversations', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ('-created',),
+            },
+        ),
+        migrations.CreateModel(
+            name='Message',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('role', models.CharField(max_length=10)),
+                ('content', models.TextField()),
+                ('code_html', models.TextField(blank=True, null=True)),
+                ('code_css', models.TextField(blank=True, null=True)),
+                ('code_js', models.TextField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('conversation', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='messages', to='prompt.conversation')),
+            ],
+            options={
+                'ordering': ('created',),
+            },
+        ),
+    ]

api/prompt/migrations/0002_message_prompt_level.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.0.1 on 2026-03-30 11:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('prompt', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='message',
+            name='prompt_level',
+            field=models.IntegerField(blank=True, db_index=True, default=None, null=True, verbose_name='提示词层级'),
+        ),
+    ]

api/prompt/migrations/0003_add_message_source.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.0.1 on 2026-03-31 07:10
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('prompt', '0002_message_prompt_level'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='message',
+            name='source',
+            field=models.CharField(default='ai', max_length=10),
+        ),
+    ]

api/prompt/migrations/0004_update_message_source_default.py

@@ -0,0 +1,18 @@
+# Generated by Django 6.0.1 on 2026-03-31 07:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('prompt', '0003_add_message_source'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='message',
+            name='source',
+            field=models.CharField(default='conversation', max_length=12),
+        ),
+    ]

api/prompt/migrations/0005_message_add_submission_fk.py

@@ -0,0 +1,20 @@
+# Generated by Django 6.0.1 on 2026-04-15 07:50
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('prompt', '0004_update_message_source_default'),
+        ('submission', '0010_remove_conversation_fk'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='message',
+            name='submission',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='source_message', to='submission.submission'),
+        ),
+    ]

api/prompt/migrations/0006_message_submission_cascade_delete.py

@@ -0,0 +1,20 @@
+# Generated by Django 6.0.1 on 2026-04-16 06:15
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('prompt', '0005_message_add_submission_fk'),
+        ('submission', '0010_remove_conversation_fk'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='message',
+            name='submission',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='source_message', to='submission.submission'),
+        ),
+    ]

api/prompt/models.py

@@ -0,0 +1,47 @@
+import uuid
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+from account.models import User
+from task.models import Task
+
+
+class Conversation(TimeStampedModel):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="conversations")
+    task = models.ForeignKey(Task, on_delete=models.CASCADE, related_name="conversations")
+    is_active = models.BooleanField(default=True, verbose_name="是否活跃")
+
+    class Meta:
+        ordering = ("-created",)
+
+    def __str__(self):
+        return f"{self.user.username} - {self.task.title}"
+
+
+class Message(models.Model):
+    conversation = models.ForeignKey(
+        Conversation, on_delete=models.CASCADE, related_name="messages"
+    )
+    role = models.CharField(max_length=10)  # "user" or "assistant"
+    source = models.CharField(max_length=12, default="conversation")  # "conversation" or "manual"
+    content = models.TextField()
+    code_html = models.TextField(null=True, blank=True)
+    code_css = models.TextField(null=True, blank=True)
+    code_js = models.TextField(null=True, blank=True)
+    created = models.DateTimeField(auto_now_add=True)
+    prompt_level = models.IntegerField(
+        null=True, blank=True, default=None, db_index=True, verbose_name="提示词层级"
+    )
+    submission = models.OneToOneField(
+        "submission.Submission",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+        related_name="source_message",
+    )
+
+    class Meta:
+        ordering = ("created",)
+
+    def __str__(self):
+        return f"[{self.role}] {self.content[:50]}"

api/prompt/schemas.py

@@ -0,0 +1,52 @@
+from typing import Optional
+from uuid import UUID
+from ninja import Schema
+
+
+class MessageOut(Schema):
+    id: int
+    role: str
+    source: str
+    content: str
+    code_html: Optional[str] = None
+    code_css: Optional[str] = None
+    code_js: Optional[str] = None
+    prompt_level: Optional[int] = None
+    created: str
+
+
+class PromptHistoryItemOut(Schema):
+    user_message_id: int
+    assistant_message_id: int
+    submission_id: Optional[UUID] = None
+    source: str
+    prompt: str
+    prompt_level: Optional[int] = None
+    code_html: Optional[str] = None
+    code_css: Optional[str] = None
+    code_js: Optional[str] = None
+    created: str
+
+
+class ConversationOut(Schema):
+    id: UUID
+    user_id: int
+    username: str
+    task_id: int
+    task_title: str
+    is_active: bool
+    message_count: int
+    created: str
+
+    @staticmethod
+    def from_conv(conv):
+        return {
+            "id": conv.id,
+            "user_id": conv.user_id,
+            "username": conv.user.username,
+            "task_id": conv.task_id,
+            "task_title": conv.task.title,
+            "is_active": conv.is_active,
+            "message_count": conv.msg_count if hasattr(conv, "msg_count") else conv.messages.count(),
+            "created": conv.created.isoformat(),
+        }

api/prompt/tests.py

@@ -0,0 +1,441 @@
+from datetime import timedelta
+from unittest.mock import patch
+
+from asgiref.sync import async_to_sync
+from django.test import TestCase
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+from task.models import Task
+from submission.models import Submission
+from prompt.models import Conversation, Message
+
+User = get_user_model()
+
+
+def _make_user(username="student1"):
+    return User.objects.create_user(username=username, password="pw")
+
+
+def _make_task():
+    return Task.objects.create(
+        title="Test Task", task_type="challenge", display=1, content=""
+    )
+
+
+class SubmissionMessageLinkTest(TestCase):
+    def setUp(self):
+        self.user = _make_user("student1")
+        self.task = _make_task()
+        self.conv = Conversation.objects.create(user=self.user, task=self.task)
+        self.user_msg = Message.objects.create(
+            conversation=self.conv, role="user", content="帮我做个按钮"
+        )
+        self.asst_msg = Message.objects.create(
+            conversation=self.conv, role="assistant", content="好的",
+            code_html="<button>OK</button>", code_css="", code_js=""
+        )
+
+    def test_create_submission_links_message(self):
+        """POST /api/submission/ with message_id links the assistant message"""
+        self.client.force_login(self.user)
+        resp = self.client.post(
+            "/api/submission/",
+            data={
+                "task_id": self.task.id,
+                "html": "<button>OK</button>",
+                "css": "",
+                "js": "",
+                "message_id": self.asst_msg.id,
+            },
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.asst_msg.refresh_from_db()
+        sub = Submission.objects.filter(user=self.user, task=self.task).first()
+        self.assertIsNotNone(sub)
+        self.assertEqual(self.asst_msg.submission, sub)
+
+    def test_create_submission_without_message_id(self):
+        """POST /api/submission/ without message_id still works"""
+        self.client.force_login(self.user)
+        resp = self.client.post(
+            "/api/submission/",
+            data={"task_id": self.task.id, "html": "<p>hi</p>", "css": "", "js": ""},
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 200)
+
+    def test_cannot_link_message_from_different_task(self):
+        """message_id from a different task is silently ignored"""
+        other_task = Task.objects.create(
+            title="Other Task", task_type="challenge", display=2, content=""
+        )
+        other_conv = Conversation.objects.create(user=self.user, task=other_task)
+        other_msg = Message.objects.create(
+            conversation=other_conv, role="assistant", content="other"
+        )
+        self.client.force_login(self.user)
+        resp = self.client.post(
+            "/api/submission/",
+            data={
+                "task_id": self.task.id,
+                "html": "<p>x</p>",
+                "css": "",
+                "js": "",
+                "message_id": other_msg.id,
+            },
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 200)
+        # Submission created, but message NOT linked (wrong task)
+        other_msg.refresh_from_db()
+        self.assertIsNone(other_msg.submission)
+
+
+class DeleteSubmissionCascadeTest(TestCase):
+    def setUp(self):
+        self.user = _make_user("student2")
+        self.task = _make_task()
+        self.conv = Conversation.objects.create(user=self.user, task=self.task)
+        self.user_msg = Message.objects.create(
+            conversation=self.conv, role="user", content="问题"
+        )
+        self.asst_msg = Message.objects.create(
+            conversation=self.conv, role="assistant", content="回答",
+            code_html="<p>hi</p>", code_css="", code_js=""
+        )
+        self.sub = Submission.objects.create(
+            user=self.user, task=self.task, html="<p>hi</p>", css="", js=""
+        )
+        self.asst_msg.submission = self.sub
+        self.asst_msg.save(update_fields=["submission"])
+
+    def test_delete_submission_also_deletes_message_pair(self):
+        """DELETE /api/submission/{id} deletes linked user+assistant messages"""
+        self.client.force_login(self.user)
+        resp = self.client.delete(f"/api/submission/{self.sub.id}")
+        self.assertEqual(resp.status_code, 200)
+        self.assertFalse(Submission.objects.filter(id=self.sub.id).exists())
+        self.assertFalse(Message.objects.filter(id=self.asst_msg.id).exists())
+        self.assertFalse(Message.objects.filter(id=self.user_msg.id).exists())
+
+    def test_delete_submission_without_linked_message(self):
+        """DELETE /api/submission/{id} works even with no linked message"""
+        sub2 = Submission.objects.create(
+            user=self.user, task=self.task, html="", css="", js=""
+        )
+        self.client.force_login(self.user)
+        resp = self.client.delete(f"/api/submission/{sub2.id}")
+        self.assertEqual(resp.status_code, 200)
+        self.assertFalse(Submission.objects.filter(id=sub2.id).exists())
+
+
+class DeleteMessagePairTest(TestCase):
+    def setUp(self):
+        self.user = _make_user("student3")
+        self.task = _make_task()
+        self.conv = Conversation.objects.create(user=self.user, task=self.task)
+        self.user_msg = Message.objects.create(
+            conversation=self.conv, role="user", content="问题"
+        )
+        self.asst_msg = Message.objects.create(
+            conversation=self.conv, role="assistant", content="回答",
+            code_html="<p>ok</p>", code_css="", code_js=""
+        )
+        self.sub = Submission.objects.create(
+            user=self.user, task=self.task, html="<p>ok</p>", css="", js=""
+        )
+        self.asst_msg.submission = self.sub
+        self.asst_msg.save(update_fields=["submission"])
+
+    def test_delete_message_pair_also_deletes_submission(self):
+        self.client.force_login(self.user)
+        resp = self.client.delete(f"/api/prompt/messages/{self.asst_msg.id}/pair")
+        self.assertEqual(resp.status_code, 200)
+        self.assertFalse(Message.objects.filter(id=self.asst_msg.id).exists())
+        self.assertFalse(Message.objects.filter(id=self.user_msg.id).exists())
+        self.assertFalse(Submission.objects.filter(id=self.sub.id).exists())
+        data = resp.json()
+        self.assertTrue(data["deleted"])
+        self.assertTrue(data["submission_deleted"])
+
+    def test_delete_message_pair_without_submission(self):
+        # Create a second pair without a submission link
+        user2 = Message.objects.create(
+            conversation=self.conv, role="user", content="另一问"
+        )
+        asst2 = Message.objects.create(
+            conversation=self.conv, role="assistant", content="另一条"
+        )
+        self.client.force_login(self.user)
+        resp = self.client.delete(f"/api/prompt/messages/{asst2.id}/pair")
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        self.assertFalse(data["submission_deleted"])
+        self.assertFalse(Message.objects.filter(id=asst2.id).exists())
+        self.assertFalse(Message.objects.filter(id=user2.id).exists())
+
+    def test_delete_message_pair_forbidden_for_other_user(self):
+        other = _make_user("other")
+        self.client.force_login(other)
+        resp = self.client.delete(f"/api/prompt/messages/{self.asst_msg.id}/pair")
+        self.assertEqual(resp.status_code, 403)
+
+
+class PromptHistoryTest(TestCase):
+    def setUp(self):
+        self.user = _make_user("history-user")
+        self.other = _make_user("history-other")
+        self.task = _make_task()
+        self.other_task = Task.objects.create(
+            title="Other Task", task_type="challenge", display=2, content=""
+        )
+
+    def _pair(
+        self,
+        user,
+        task,
+        prompt,
+        source="conversation",
+        html="<main>page</main>",
+        css="main { color: red; }",
+        js="",
+    ):
+        conv = Conversation.objects.create(user=user, task=task)
+        user_msg = Message.objects.create(
+            conversation=conv,
+            role="user",
+            source=source,
+            content=prompt,
+        )
+        asst_msg = Message.objects.create(
+            conversation=conv,
+            role="assistant",
+            source=source,
+            content="" if source == "manual" else "answer",
+            code_html=html,
+            code_css=css,
+            code_js=js,
+        )
+        return user_msg, asst_msg
+
+    def test_history_returns_ai_and_manual_prompt_rounds_with_page_code(self):
+        ai_user, ai_asst = self._pair(self.user, self.task, "做一个登录页")
+        manual_user, manual_asst = self._pair(
+            self.user,
+            self.task,
+            "我让外部 AI 做一个卡片",
+            source="manual",
+            html="<section>card</section>",
+        )
+
+        self.client.force_login(self.user)
+        resp = self.client.get(f"/api/prompt/history/{self.task.id}")
+
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        ids = {item["user_message_id"] for item in data}
+        self.assertEqual(ids, {ai_user.id, manual_user.id})
+        by_source = {item["source"]: item for item in data}
+        self.assertEqual(by_source["conversation"]["assistant_message_id"], ai_asst.id)
+        self.assertEqual(by_source["conversation"]["prompt"], "做一个登录页")
+        self.assertEqual(by_source["manual"]["assistant_message_id"], manual_asst.id)
+        self.assertEqual(by_source["manual"]["code_html"], "<section>card</section>")
+        self.assertNotIn("content", by_source["conversation"])
+
+    def test_history_is_ordered_old_to_new(self):
+        newest_user, newest_asst = self._pair(self.user, self.task, "第三条")
+        oldest_user, oldest_asst = self._pair(self.user, self.task, "第一条")
+        middle_user, middle_asst = self._pair(self.user, self.task, "第二条")
+        base = timezone.now()
+        for offset, user_msg, asst_msg in [
+            (0, oldest_user, oldest_asst),
+            (1, middle_user, middle_asst),
+            (2, newest_user, newest_asst),
+        ]:
+            user_created = base + timedelta(minutes=offset)
+            Message.objects.filter(id=user_msg.id).update(created=user_created)
+            Message.objects.filter(id=asst_msg.id).update(
+                created=user_created + timedelta(seconds=1)
+            )
+
+        self.client.force_login(self.user)
+        resp = self.client.get(f"/api/prompt/history/{self.task.id}")
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(
+            [item["prompt"] for item in resp.json()],
+            ["第一条", "第二条", "第三条"],
+        )
+
+    def test_history_is_scoped_to_current_user_and_task(self):
+        own_user, _ = self._pair(self.user, self.task, "自己的提示词")
+        self._pair(self.other, self.task, "别人的提示词")
+        self._pair(self.user, self.other_task, "其他任务提示词")
+
+        self.client.force_login(self.user)
+        resp = self.client.get(f"/api/prompt/history/{self.task.id}")
+
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        self.assertEqual(len(data), 1)
+        self.assertEqual(data[0]["user_message_id"], own_user.id)
+        self.assertEqual(data[0]["prompt"], "自己的提示词")
+
+    def test_history_keeps_rounds_without_page_code(self):
+        conv = Conversation.objects.create(user=self.user, task=self.task)
+        user_msg = Message.objects.create(conversation=conv, role="user", content="只聊天")
+        asst_msg = Message.objects.create(conversation=conv, role="assistant", content="没有代码")
+
+        self.client.force_login(self.user)
+        resp = self.client.get(f"/api/prompt/history/{self.task.id}")
+
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        self.assertEqual(len(data), 1)
+        self.assertEqual(data[0]["user_message_id"], user_msg.id)
+        self.assertEqual(data[0]["assistant_message_id"], asst_msg.id)
+        self.assertIsNone(data[0]["code_html"])
+        self.assertIsNone(data[0]["code_css"])
+        self.assertIsNone(data[0]["code_js"])
+
+
+from prompt.llm import (
+    DEFAULT_MODEL,
+    GUIDANCE_SYSTEM_PROMPT,
+    parse_guidance_response,
+    stream_chat,
+    stream_guidance,
+)
+
+
+class _FakeDelta:
+    def __init__(self, content):
+        self.content = content
+
+
+class _FakeChoice:
+    def __init__(self, content):
+        self.delta = _FakeDelta(content)
+
+
+class _FakeChunk:
+    def __init__(self, content):
+        self.choices = [_FakeChoice(content)]
+
+
+class _FakeStream:
+    def __init__(self, chunks):
+        self._chunks = iter(chunks)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            return _FakeChunk(next(self._chunks))
+        except StopIteration:
+            raise StopAsyncIteration
+
+
+class _FakeCompletions:
+    def __init__(self):
+        self.kwargs = None
+
+    async def create(self, **kwargs):
+        self.kwargs = kwargs
+        return _FakeStream(["ok"])
+
+
+class _FakeChat:
+    def __init__(self, completions):
+        self.completions = completions
+
+
+class _FakeClient:
+    def __init__(self):
+        self.completions = _FakeCompletions()
+        self.chat = _FakeChat(self.completions)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return None
+
+
+async def _collect_stream(stream):
+    return [chunk async for chunk in stream]
+
+
+class DeepSeekThinkingModeTest(TestCase):
+    def test_stream_chat_disables_thinking_for_deepseek_flash(self):
+        client = _FakeClient()
+
+        with patch("prompt.llm._get_client", return_value=(client, DEFAULT_MODEL)):
+            chunks = async_to_sync(_collect_stream)(
+                stream_chat([{"role": "user", "content": "做一个按钮"}])
+            )
+
+        self.assertEqual(chunks, ["ok"])
+        self.assertEqual(
+            client.completions.kwargs["extra_body"],
+            {"thinking": {"type": "disabled"}},
+        )
+
+    def test_stream_guidance_disables_thinking_for_deepseek_flash(self):
+        client = _FakeClient()
+
+        with patch("prompt.llm._get_client", return_value=(client, DEFAULT_MODEL)):
+            chunks = async_to_sync(_collect_stream)(
+                stream_guidance([{"role": "user", "content": "做一个页面"}])
+            )
+
+        self.assertEqual(chunks, ["ok"])
+        self.assertEqual(
+            client.completions.kwargs["extra_body"],
+            {"thinking": {"type": "disabled"}},
+        )
+
+    def test_stream_chat_thinking_option_uses_deepseek_flash_without_disabling_thinking(self):
+        client = _FakeClient()
+
+        with patch("prompt.llm.AsyncOpenAI", return_value=client):
+            chunks = async_to_sync(_collect_stream)(
+                stream_chat(
+                    [{"role": "user", "content": "做一个按钮"}],
+                    model="deepseek-v4-flash-thinking",
+                )
+            )
+
+        self.assertEqual(chunks, ["ok"])
+        self.assertEqual(client.completions.kwargs["model"], DEFAULT_MODEL)
+        self.assertNotIn("extra_body", client.completions.kwargs)
+
+
+class ParseGuidanceResponseTest(TestCase):
+    def test_guidance_prompt_asks_for_bold_keywords(self):
+        self.assertIn("Markdown", GUIDANCE_SYSTEM_PROMPT)
+        self.assertIn("[READY] 不要加粗", GUIDANCE_SYSTEM_PROMPT)
+        for keyword in ("**主题**", "**视觉**", "**交互**", "**内容**", "**可以生成**"):
+            self.assertIn(keyword, GUIDANCE_SYSTEM_PROMPT)
+
+    def test_ready_prefix_with_newline_stripped(self):
+        content, is_ready = parse_guidance_response("[READY]\n很好，可以生成了！")
+        self.assertEqual(content, "很好，可以生成了！")
+        self.assertTrue(is_ready)
+
+    def test_ready_prefix_without_newline_stripped(self):
+        content, is_ready = parse_guidance_response("[READY]很好，可以生成了！")
+        self.assertEqual(content, "很好，可以生成了！")
+        self.assertTrue(is_ready)
+
+    def test_no_ready_prefix_unchanged(self):
+        content, is_ready = parse_guidance_response("你的提示词不够具体，请问...")
+        self.assertEqual(content, "你的提示词不够具体，请问...")
+        self.assertFalse(is_ready)
+
+    def test_empty_string(self):
+        content, is_ready = parse_guidance_response("")
+        self.assertEqual(content, "")
+        self.assertFalse(is_ready)

api/prompt/url.py

@@ -0,0 +1,15 @@
+from collections.abc import Callable
+from typing import Any, cast
+
+from django.urls import path
+from django.urls.resolvers import URLPattern, URLResolver
+
+from .consumers import PromptConsumer, GuidanceConsumer
+
+AsgiApplication = Callable[..., Any]
+RoutePattern = URLPattern | URLResolver
+
+websocket_urlpatterns: list[RoutePattern] = [
+    path("ws/prompt/<int:task_id>/", cast(AsgiApplication, PromptConsumer.as_asgi())),
+    path("ws/guidance/<int:task_id>/", cast(AsgiApplication, GuidanceConsumer.as_asgi())),
+]

api/prompt/utils.py

@@ -0,0 +1,45 @@
+from django.db.models import Count, Q
+from .models import Conversation
+
+
+def can_access_task(user, task_id):
+    """自由创作只有创作者本人（和超管）能对话，其他任务对所有登录用户开放。"""
+    from account.models import RoleChoices
+    from task.models import Creation
+
+    owner_id = (
+        Creation.objects.filter(pk=task_id).values_list("owner_id", flat=True).first()
+    )
+    if owner_id is None:
+        return True
+    return owner_id == user.id or user.role == RoleChoices.SUPER
+
+
+def get_active_conversation(user, task_id):
+    """Return the conversation with the most messages for this user+task, or None."""
+    return (
+        Conversation.objects.filter(user=user, task_id=task_id)
+        .annotate(msg_count=Count("messages"))
+        .order_by("-msg_count", "-created")
+        .first()
+    )
+
+
+def get_or_create_active_conversation(user, task_id):
+    conv = get_active_conversation(user, task_id)
+    if not conv:
+        conv = Conversation.objects.create(user=user, task_id=task_id)
+    return conv
+
+
+def get_preceding_user_message(asst_msg):
+    """Return the user message immediately preceding an assistant message in its conversation."""
+    return (
+        asst_msg.conversation.messages.filter(role="user")
+        .filter(
+            Q(created__lt=asst_msg.created)
+            | Q(created=asst_msg.created, id__lt=asst_msg.id)
+        )
+        .order_by("-created", "-id")
+        .first()
+    )