Upload 19 files

core.py

@@ -39,6 +39,7 @@ issues_collection = db.project_issues
 image_assets_collection = db.image_assets
 team_chat_collection = db.team_chat_history
 team_docs_collection = db.team_documents
+team_doc_chunks_collection = db.team_document_chunks
 
 UPLOAD_DIR = os.environ.get("UPLOAD_DIR", os.path.join(os.path.dirname(__file__), "uploads"))
 os.makedirs(UPLOAD_DIR, exist_ok=True)

routes_team_chat.py

@@ -8,7 +8,7 @@ from fastapi import APIRouter, File, Form, Header, HTTPException, UploadFile, We
 
 from core import TEAM_AGENT_MODEL, projects_collection, team_chat_collection, teams_collection
 from prompts import TEAM_AGENT_SYSTEM_PROMPT
-from schemas import TeamChatRequest
+from schemas import TeamChatMessageRequest, TeamChatRequest
 from services import (
     build_document_grounded_answer,
     build_requirement_node_options_from_documents,
@@ -322,7 +322,7 @@ async def upload_team_document(
             "mime_type": doc["mime_type"],
             "created_at": doc["created_at"],
             "updated_at": doc["updated_at"],
-            "total_nodes": (doc.get("tree") or {}).get("total_nodes", 0),
+            "total_nodes": (doc.get("tree") or {}).get("total_nodes", (doc.get("tree_meta") or {}).get("total_nodes", 0)),
         }
     }
 
@@ -363,6 +363,30 @@ async def upload_team_chat_images(
     }
 
 
+@router.post("/teams/{team_id}/chat/messages")
+async def post_team_chat_message(
+    team_id: str,
+    req: TeamChatMessageRequest,
+    x_session_token: Optional[str] = Header(None, alias="X-Session-Token"),
+):
+    user = require_session_user(x_session_token)
+    _assert_team_project_access(user, team_id, req.project_id)
+
+    content = (req.message or "").strip()
+    if not content and not (req.attachment_urls or []):
+        raise HTTPException(status_code=400, detail="Message is empty")
+
+    user_msg = save_team_chat_message(
+        team_id,
+        "user",
+        content,
+        req.project_id,
+        attachment_urls=req.attachment_urls,
+    )
+    await _broadcast_team_chat_message(team_id, req.project_id, user_msg)
+    return {"message": user_msg}
+
+
 @router.post("/teams/chat")
 async def team_chat(req: TeamChatRequest, x_session_token: Optional[str] = Header(None, alias="X-Session-Token")):
     user = require_session_user(x_session_token)

schemas.py

@@ -128,6 +128,12 @@ class TeamChatRequest(BaseModel):
     require_bot_mention: bool = True
 
 
+class TeamChatMessageRequest(BaseModel):
+    message: str
+    project_id: Optional[str] = None
+    attachment_urls: List[str] = Field(default_factory=list)
+
+
 class TeamChatToolCreateIssue(BaseModel):
     title: str
     description: str = ""

services_legacy.py

@@ -49,6 +49,7 @@ from core import (
     tasks_collection,
     TEAM_AGENT_MODEL,
     team_chat_collection,
+    team_doc_chunks_collection,
     team_docs_collection,
     teams_collection,
     users_collection,
@@ -66,6 +67,9 @@ _tts_tokenizer = None
 _tts_model = None
 _last_auto_compact_ts = 0.0
 
+TEAM_DOC_NODE_CONTENT_LIMIT = int(os.environ.get("TEAM_DOC_NODE_CONTENT_LIMIT", "2400"))
+TEAM_DOC_NODE_CHUNK_SIZE = int(os.environ.get("TEAM_DOC_NODE_CHUNK_SIZE", "80"))
+
 
 def get_vn_now() -> datetime:
     return datetime.now(tz=VN_TZ)
@@ -638,6 +642,133 @@ def _safe_decode_text(raw_bytes: bytes, fallback_name: str = "") -> str:
     return raw_bytes.decode("utf-8", errors="ignore")
 
 
+def _split_large_node_content(tree: Dict[str, Any], max_chars: int = TEAM_DOC_NODE_CONTENT_LIMIT) -> Dict[str, Any]:
+    nodes = tree.get("nodes") or []
+    if not nodes:
+        return tree
+
+    by_id: Dict[str, Dict[str, Any]] = {str(node.get("id") or ""): node for node in nodes if node.get("id")}
+    root_id = str(tree.get("root_id") or "root")
+    next_split_idx = 0
+    normalized_nodes: List[Dict[str, Any]] = []
+
+    for node in nodes:
+        node_id = str(node.get("id") or "")
+        clone = dict(node)
+        clone["children"] = list(node.get("children") or [])
+        content = str(clone.get("content") or "")
+
+        if node_id == root_id or len(content) <= max_chars:
+            normalized_nodes.append(clone)
+            continue
+
+        parts = [content[i : i + max_chars].strip() for i in range(0, len(content), max_chars)]
+        parts = [part for part in parts if part]
+        if not parts:
+            clone["content"] = ""
+            normalized_nodes.append(clone)
+            continue
+
+        clone["content"] = parts[0]
+        clone["summary"] = _clip_text(parts[0], 280)
+        clone["contextual_summary"] = _clip_text(parts[0], 260)
+
+        parent_level = int(clone.get("level") or 1)
+        continuation_children = list(clone.get("children") or [])
+        title = str(clone.get("title") or "Section")
+        normalized_nodes.append(clone)
+
+        for idx, part in enumerate(parts[1:], start=2):
+            next_split_idx += 1
+            split_id = f"{node_id}_part_{next_split_idx}"
+            while split_id in by_id:
+                next_split_idx += 1
+                split_id = f"{node_id}_part_{next_split_idx}"
+
+            child_node = {
+                "id": split_id,
+                "parent_id": node_id,
+                "level": parent_level + 1,
+                "title": f"{title} (phần {idx})",
+                "summary": _clip_text(part, 280),
+                "contextual_summary": _clip_text(part, 260),
+                "scope": f"Nội dung tiếp theo của: {title}",
+                "content": part,
+                "children": [],
+            }
+            continuation_children.append(split_id)
+            by_id[split_id] = child_node
+            normalized_nodes.append(child_node)
+
+        clone["children"] = continuation_children
+
+    return {
+        "root_id": root_id,
+        "nodes": normalized_nodes,
+        "total_nodes": len(normalized_nodes),
+    }
+
+
+def _chunk_document_nodes(nodes: List[Dict[str, Any]], chunk_size: int = TEAM_DOC_NODE_CHUNK_SIZE) -> List[List[Dict[str, Any]]]:
+    if not nodes:
+        return []
+    size = max(1, int(chunk_size))
+    return [nodes[i : i + size] for i in range(0, len(nodes), size)]
+
+
+def _store_team_document_chunks(doc_id: str, nodes: List[Dict[str, Any]], created_at: str) -> None:
+    chunks = _chunk_document_nodes(nodes)
+    if not chunks:
+        return
+
+    chunk_docs = [
+        {
+            "id": str(uuid.uuid4()),
+            "doc_id": doc_id,
+            "chunk_index": idx,
+            "nodes": chunk_nodes,
+            "created_at": created_at,
+            "updated_at": created_at,
+        }
+        for idx, chunk_nodes in enumerate(chunks)
+    ]
+    team_doc_chunks_collection.insert_many(chunk_docs)
+
+
+def _load_team_document_nodes(doc_id: str) -> List[Dict[str, Any]]:
+    rows = list(
+        team_doc_chunks_collection.find(
+            {"doc_id": doc_id},
+            {"_id": 0, "nodes": 1},
+        ).sort("chunk_index", 1)
+    )
+    nodes: List[Dict[str, Any]] = []
+    for row in rows:
+        chunk_nodes = row.get("nodes")
+        if isinstance(chunk_nodes, list):
+            nodes.extend(chunk_nodes)
+    return nodes
+
+
+def _resolve_document_tree(doc: Dict[str, Any]) -> Dict[str, Any]:
+    inline_tree = doc.get("tree") if isinstance(doc.get("tree"), dict) else None
+    if inline_tree and isinstance(inline_tree.get("nodes"), list):
+        total_nodes = inline_tree.get("total_nodes")
+        if not isinstance(total_nodes, int):
+            inline_tree["total_nodes"] = len(inline_tree.get("nodes") or [])
+        return inline_tree
+
+    tree_meta = doc.get("tree_meta") if isinstance(doc.get("tree_meta"), dict) else {}
+    nodes = _load_team_document_nodes(str(doc.get("id") or ""))
+    root_id = str(tree_meta.get("root_id") or "root")
+    total_nodes = int(tree_meta.get("total_nodes") or len(nodes))
+    return {
+        "root_id": root_id,
+        "nodes": nodes,
+        "total_nodes": total_nodes,
+    }
+
+
 def build_document_tree(text: str) -> Dict[str, Any]:
     lines = (text or "").splitlines()
     nodes: List[Dict[str, Any]] = []
@@ -813,24 +944,49 @@ def save_team_document(
     raw_bytes: bytes,
 ) -> Dict[str, Any]:
     text = _safe_decode_text(raw_bytes, file_name)
-    tree = build_document_tree(text)
+    tree = _split_large_node_content(build_document_tree(text))
     contextual_meta = _contextualize_document_tree(file_name=file_name, text=text, tree=tree)
+    doc_id = str(uuid.uuid4())
+    now_iso = get_vn_now().isoformat()
+
     doc = {
-        "id": str(uuid.uuid4()),
+        "id": doc_id,
         "team_id": team_id,
         "project_id": project_id,
         "name": file_name,
         "mime_type": mime_type,
         "uploader_id": uploader_id,
-        "tree": tree,
-        "text": text,
+        "tree_meta": {
+            "root_id": tree.get("root_id", "root"),
+            "total_nodes": int(tree.get("total_nodes") or len(tree.get("nodes") or [])),
+            "storage": "chunked",
+            "chunk_size": TEAM_DOC_NODE_CHUNK_SIZE,
+        },
+        "text_meta": {
+            "raw_bytes": len(raw_bytes),
+            "decoded_chars": len(text),
+            "storage": "transient",
+        },
         "contextual_global_summary": contextual_meta.get("global_summary", ""),
         "contextual_meta": contextual_meta,
-        "created_at": get_vn_now().isoformat(),
-        "updated_at": get_vn_now().isoformat(),
+        "created_at": now_iso,
+        "updated_at": now_iso,
     }
-    team_docs_collection.insert_one(doc)
-    return doc
+
+    try:
+        team_docs_collection.insert_one(doc)
+        _store_team_document_chunks(doc_id=doc_id, nodes=tree.get("nodes") or [], created_at=now_iso)
+    except Exception:
+        team_docs_collection.delete_many({"id": doc_id})
+        team_doc_chunks_collection.delete_many({"doc_id": doc_id})
+        raise
+
+    out_doc = dict(doc)
+    out_doc["tree"] = {
+        "root_id": tree.get("root_id", "root"),
+        "total_nodes": tree.get("total_nodes", len(tree.get("nodes") or [])),
+    }
+    return out_doc
 
 
 def list_team_documents(team_id: str, project_id: Optional[str] = None) -> List[Dict[str, Any]]:
@@ -850,19 +1006,18 @@ def list_team_documents(team_id: str, project_id: Optional[str] = None) -> List[
                 "uploader_id": 1,
                 "created_at": 1,
                 "updated_at": 1,
-                "tree.total_nodes": 1,
-                "tree.nodes.id": 1,
-                "tree.nodes.parent_id": 1,
-                "tree.nodes.level": 1,
-                "tree.nodes.title": 1,
-                "tree.nodes.summary": 1,
-                "tree.nodes.contextual_summary": 1,
+                "tree": 1,
+                "tree_meta": 1,
             },
         ).sort("updated_at", -1)
     )
     for doc in docs:
-        tree = doc.get("tree") or {}
+        tree = _resolve_document_tree(doc)
         nodes = tree.get("nodes") or []
+        doc["tree"] = {
+            "root_id": tree.get("root_id", "root"),
+            "total_nodes": int(tree.get("total_nodes") or len(nodes)),
+        }
         doc["node_catalog"] = [
             {
                 "id": node.get("id"),
@@ -887,7 +1042,28 @@ def get_team_documents_by_ids(team_id: str, doc_ids: List[str], project_id: Opti
     query: Dict[str, Any] = {"team_id": team_id, "id": {"$in": doc_ids}}
     if project_id:
         query["project_id"] = project_id
-    docs = list(team_docs_collection.find(query, {"_id": 0}))
+    docs = list(
+        team_docs_collection.find(
+            query,
+            {
+                "_id": 0,
+                "id": 1,
+                "team_id": 1,
+                "project_id": 1,
+                "name": 1,
+                "mime_type": 1,
+                "uploader_id": 1,
+                "contextual_global_summary": 1,
+                "contextual_meta": 1,
+                "created_at": 1,
+                "updated_at": 1,
+                "tree": 1,
+                "tree_meta": 1,
+            },
+        )
+    )
+    for doc in docs:
+        doc["tree"] = _resolve_document_tree(doc)
     by_id = {doc.get("id"): doc for doc in docs}
     ordered = [by_id[doc_id] for doc_id in doc_ids if doc_id in by_id]
     return ordered