feat: Phase 2 交互与纠错工作台完成

- 新增实体编辑 API (名称、类型、定义、别名)
- 新增实体删除和合并功能
- 新增关系管理 (创建、删除)
- 新增转录文本编辑功能
- 新增划词创建实体功能
- 前端新增实体编辑器模态框
- 前端新增右键菜单和工具栏
- 文本与图谱双向联动优化

backend/db_manager.py

@@ -290,6 +290,104 @@ class DatabaseManager:
         ).fetchall()
         conn.close()
         return [dict(r) for r in rows]
+    
+    def update_entity(self, entity_id: str, **kwargs) -> Entity:
+        """更新实体信息"""
+        conn = self.get_conn()
+        
+        # 构建更新字段
+        allowed_fields = ['name', 'type', 'definition', 'canonical_name']
+        updates = []
+        values = []
+        
+        for field in allowed_fields:
+            if field in kwargs:
+                updates.append(f"{field} = ?")
+                values.append(kwargs[field])
+        
+        # 处理别名
+        if 'aliases' in kwargs:
+            updates.append("aliases = ?")
+            values.append(json.dumps(kwargs['aliases']))
+        
+        if not updates:
+            conn.close()
+            return self.get_entity(entity_id)
+        
+        updates.append("updated_at = ?")
+        values.append(datetime.now().isoformat())
+        values.append(entity_id)
+        
+        query = f"UPDATE entities SET {', '.join(updates)} WHERE id = ?"
+        conn.execute(query, values)
+        conn.commit()
+        conn.close()
+        
+        return self.get_entity(entity_id)
+    
+    def delete_entity(self, entity_id: str):
+        """删除实体及其关联数据"""
+        conn = self.get_conn()
+        
+        # 删除提及记录
+        conn.execute("DELETE FROM entity_mentions WHERE entity_id = ?", (entity_id,))
+        
+        # 删除关系
+        conn.execute("DELETE FROM entity_relations WHERE source_entity_id = ? OR target_entity_id = ?", 
+                     (entity_id, entity_id))
+        
+        # 删除实体
+        conn.execute("DELETE FROM entities WHERE id = ?", (entity_id,))
+        
+        conn.commit()
+        conn.close()
+    
+    def delete_relation(self, relation_id: str):
+        """删除关系"""
+        conn = self.get_conn()
+        conn.execute("DELETE FROM entity_relations WHERE id = ?", (relation_id,))
+        conn.commit()
+        conn.close()
+    
+    def update_relation(self, relation_id: str, **kwargs) -> dict:
+        """更新关系"""
+        conn = self.get_conn()
+        
+        allowed_fields = ['relation_type', 'evidence']
+        updates = []
+        values = []
+        
+        for field in allowed_fields:
+            if field in kwargs:
+                updates.append(f"{field} = ?")
+                values.append(kwargs[field])
+        
+        if updates:
+            query = f"UPDATE entity_relations SET {', '.join(updates)} WHERE id = ?"
+            values.append(relation_id)
+            conn.execute(query, values)
+            conn.commit()
+        
+        row = conn.execute("SELECT * FROM entity_relations WHERE id = ?", (relation_id,)).fetchone()
+        conn.close()
+        
+        return dict(row) if row else None
+    
+    def update_transcript(self, transcript_id: str, full_text: str) -> dict:
+        """更新转录文本"""
+        conn = self.get_conn()
+        now = datetime.now().isoformat()
+        
+        conn.execute(
+            "UPDATE transcripts SET full_text = ?, updated_at = ? WHERE id = ?",
+            (full_text, now, transcript_id)
+        )
+        conn.commit()
+        
+        row = conn.execute("SELECT * FROM transcripts WHERE id = ?", (transcript_id,)).fetchone()
+        conn.close()
+        
+        return dict(row) if row else None
 
 
 # Singleton instance

backend/main.py

@@ -71,10 +71,251 @@ class ProjectCreate(BaseModel):
     name: str
     description: str = ""
 
+class EntityUpdate(BaseModel):
+    name: Optional[str] = None
+    type: Optional[str] = None
+    definition: Optional[str] = None
+    aliases: Optional[List[str]] = None
+
+class RelationCreate(BaseModel):
+    source_entity_id: str
+    target_entity_id: str
+    relation_type: str
+    evidence: Optional[str] = ""
+
+class TranscriptUpdate(BaseModel):
+    full_text: str
+
+class EntityMergeRequest(BaseModel):
+    source_entity_id: str
+    target_entity_id: str
+
 # API Keys
 KIMI_API_KEY = os.getenv("KIMI_API_KEY", "")
 KIMI_BASE_URL = "https://api.kimi.com/coding"
 
+# Phase 2: Entity Edit API
+@app.put("/api/v1/entities/{entity_id}")
+async def update_entity(entity_id: str, update: EntityUpdate):
+    """更新实体信息（名称、类型、定义、别名）"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    entity = db.get_entity(entity_id)
+    if not entity:
+        raise HTTPException(status_code=404, detail="Entity not found")
+    
+    # 更新字段
+    update_data = {k: v for k, v in update.dict().items() if v is not None}
+    updated = db.update_entity(entity_id, **update_data)
+    
+    return {
+        "id": updated.id,
+        "name": updated.name,
+        "type": updated.type,
+        "definition": updated.definition,
+        "aliases": updated.aliases
+    }
+
+@app.delete("/api/v1/entities/{entity_id}")
+async def delete_entity(entity_id: str):
+    """删除实体"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    entity = db.get_entity(entity_id)
+    if not entity:
+        raise HTTPException(status_code=404, detail="Entity not found")
+    
+    db.delete_entity(entity_id)
+    return {"success": True, "message": f"Entity {entity_id} deleted"}
+
+@app.post("/api/v1/entities/{entity_id}/merge")
+async def merge_entities_endpoint(entity_id: str, merge_req: EntityMergeRequest):
+    """合并两个实体"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    
+    # 验证两个实体都存在
+    source = db.get_entity(merge_req.source_entity_id)
+    target = db.get_entity(merge_req.target_entity_id)
+    
+    if not source or not target:
+        raise HTTPException(status_code=404, detail="Entity not found")
+    
+    result = db.merge_entities(merge_req.target_entity_id, merge_req.source_entity_id)
+    return {
+        "success": True,
+        "merged_entity": {
+            "id": result.id,
+            "name": result.name,
+            "type": result.type,
+            "definition": result.definition,
+            "aliases": result.aliases
+        }
+    }
+
+# Phase 2: Relation Edit API
+@app.post("/api/v1/projects/{project_id}/relations")
+async def create_relation_endpoint(project_id: str, relation: RelationCreate):
+    """创建新的实体关系"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    
+    # 验证实体存在
+    source = db.get_entity(relation.source_entity_id)
+    target = db.get_entity(relation.target_entity_id)
+    
+    if not source or not target:
+        raise HTTPException(status_code=404, detail="Source or target entity not found")
+    
+    relation_id = db.create_relation(
+        project_id=project_id,
+        source_entity_id=relation.source_entity_id,
+        target_entity_id=relation.target_entity_id,
+        relation_type=relation.relation_type,
+        evidence=relation.evidence
+    )
+    
+    return {
+        "id": relation_id,
+        "source_id": relation.source_entity_id,
+        "target_id": relation.target_entity_id,
+        "type": relation.relation_type,
+        "success": True
+    }
+
+@app.delete("/api/v1/relations/{relation_id}")
+async def delete_relation(relation_id: str):
+    """删除关系"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    db.delete_relation(relation_id)
+    return {"success": True, "message": f"Relation {relation_id} deleted"}
+
+@app.put("/api/v1/relations/{relation_id}")
+async def update_relation(relation_id: str, relation: RelationCreate):
+    """更新关系"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    updated = db.update_relation(
+        relation_id=relation_id,
+        relation_type=relation.relation_type,
+        evidence=relation.evidence
+    )
+    
+    return {
+        "id": relation_id,
+        "type": updated["relation_type"],
+        "evidence": updated["evidence"],
+        "success": True
+    }
+
+# Phase 2: Transcript Edit API
+@app.get("/api/v1/transcripts/{transcript_id}")
+async def get_transcript(transcript_id: str):
+    """获取转录详情"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    transcript = db.get_transcript(transcript_id)
+    
+    if not transcript:
+        raise HTTPException(status_code=404, detail="Transcript not found")
+    
+    return transcript
+
+@app.put("/api/v1/transcripts/{transcript_id}")
+async def update_transcript(transcript_id: str, update: TranscriptUpdate):
+    """更新转录文本（人工修正）"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    transcript = db.get_transcript(transcript_id)
+    
+    if not transcript:
+        raise HTTPException(status_code=404, detail="Transcript not found")
+    
+    updated = db.update_transcript(transcript_id, update.full_text)
+    return {
+        "id": transcript_id,
+        "full_text": updated["full_text"],
+        "updated_at": updated["updated_at"],
+        "success": True
+    }
+
+# Phase 2: Manual Entity Creation
+class ManualEntityCreate(BaseModel):
+    name: str
+    type: str = "OTHER"
+    definition: str = ""
+    transcript_id: Optional[str] = None
+    start_pos: Optional[int] = None
+    end_pos: Optional[int] = None
+
+@app.post("/api/v1/projects/{project_id}/entities")
+async def create_manual_entity(project_id: str, entity: ManualEntityCreate):
+    """手动创建实体（划词新建）"""
+    if not DB_AVAILABLE:
+        raise HTTPException(status_code=500, detail="Database not available")
+    
+    db = get_db_manager()
+    
+    # 检查是否已存在
+    existing = db.get_entity_by_name(project_id, entity.name)
+    if existing:
+        return {
+            "id": existing.id,
+            "name": existing.name,
+            "type": existing.type,
+            "existed": True
+        }
+    
+    entity_id = str(uuid.uuid4())[:8]
+    new_entity = db.create_entity(Entity(
+        id=entity_id,
+        project_id=project_id,
+        name=entity.name,
+        type=entity.type,
+        definition=entity.definition
+    ))
+    
+    # 如果有提及位置信息，保存提及
+    if entity.transcript_id and entity.start_pos is not None and entity.end_pos is not None:
+        transcript = db.get_transcript(entity.transcript_id)
+        if transcript:
+            text = transcript["full_text"]
+            mention = EntityMention(
+                id=str(uuid.uuid4())[:8],
+                entity_id=entity_id,
+                transcript_id=entity.transcript_id,
+                start_pos=entity.start_pos,
+                end_pos=entity.end_pos,
+                text_snippet=text[max(0, entity.start_pos-20):min(len(text), entity.end_pos+20)],
+                confidence=1.0
+            )
+            db.add_mention(mention)
+    
+    return {
+        "id": new_entity.id,
+        "name": new_entity.name,
+        "type": new_entity.type,
+        "definition": new_entity.definition,
+        "success": True
+    }
+
 def transcribe_audio(audio_data: bytes, filename: str) -> dict:
     """转录音频：OSS上传 + 听悟转录"""
     
@@ -379,14 +620,31 @@ async def get_entity_mentions(entity_id: str):
     } for m in mentions]
 
 @app.post("/api/v1/entities/{entity_id}/merge")
-async def merge_entities(entity_id: str, target_entity_id: str):
+async def merge_entities_endpoint(entity_id: str, merge_req: EntityMergeRequest):
     """合并两个实体"""
     if not DB_AVAILABLE:
         raise HTTPException(status_code=500, detail="Database not available")
     
     db = get_db_manager()
-    result = db.merge_entities(target_entity_id, entity_id)
-    return {"success": True, "merged_entity": {"id": result.id, "name": result.name}}
+    
+    # 验证两个实体都存在
+    source = db.get_entity(merge_req.source_entity_id)
+    target = db.get_entity(merge_req.target_entity_id)
+    
+    if not source or not target:
+        raise HTTPException(status_code=404, detail="Entity not found")
+    
+    result = db.merge_entities(merge_req.target_entity_id, merge_req.source_entity_id)
+    return {
+        "success": True,
+        "merged_entity": {
+            "id": result.id,
+            "name": result.name,
+            "type": result.type,
+            "definition": result.definition,
+            "aliases": result.aliases
+        }
+    }
 
 # Health check
 @app.get("/health")