1525 lines
63 KiB
Python
1525 lines
63 KiB
Python
"""Draft generation service for write-operation confirmation."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import json
|
||
import re
|
||
from difflib import SequenceMatcher
|
||
from datetime import timedelta
|
||
from typing import Any, Optional
|
||
|
||
from sqlalchemy import and_, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from ...config.ai_prompts import PROMPT_DRAFT_GENERATOR
|
||
from ...core.logging import get_logger
|
||
from ...models import AICallLog, User, UserWorkload, WorkItem
|
||
from ...utils.timezone import now_cn_naive
|
||
from ..llm_service import llm_service
|
||
|
||
logger = get_logger(__name__)
|
||
|
||
_DRAFT_TIMEOUT_HOURS = 24
|
||
_DRAFT_GENERATOR_INITIAL_MAX_TOKENS = 2_200
|
||
_DRAFT_GENERATOR_MAX_TOKENS = 100_000
|
||
_DRAFT_GENERATOR_TIMEOUT_SECONDS = 180.0
|
||
_FEASIBILITY_ALLOWED = {"合理", "待讨论", "不合理"}
|
||
_DEFAULT_DRAFT_TITLE = "需求草稿"
|
||
_DEFAULT_DRAFT_MVP_ITEMS = [
|
||
"明确项目目标与边界",
|
||
"完成同名/相似项目查重",
|
||
"交付最小可验证闭环",
|
||
]
|
||
_DEFAULT_DRAFT_FOLLOWUP_PLAN = [
|
||
{"when": "明天", "action": "确认触发时机与验收口径"},
|
||
{"when": "一周后", "action": "复核执行效果并决定是否扩展"},
|
||
]
|
||
_DEFAULT_DRAFT_FEASIBILITY_REASON = "信息仍需补充，建议先确认边界。"
|
||
_DEFAULT_DRAFT_PROSPECT_ASSESSMENT = "该项目具备落地价值，但建议先确认范围边界和现有项目复用情况，再决定是否推进。"
|
||
|
||
|
||
class DraftGeneratorService:
|
||
"""Generate and persist draft payload for write intents."""
|
||
|
||
def __init__(self, db: AsyncSession, *, tenant_id: int) -> None:
|
||
self.db = db
|
||
self.tenant_id = int(tenant_id)
|
||
|
||
async def generate_and_persist(
|
||
self,
|
||
*,
|
||
work_item: WorkItem,
|
||
intent_name: str,
|
||
message_text: str,
|
||
world_model: dict[str, Any],
|
||
revision_note: Optional[str] = None,
|
||
) -> dict[str, Any]:
|
||
current_version = int(work_item.draft_version or 0)
|
||
next_version = current_version + 1
|
||
previous_draft = work_item.draft_content if isinstance(work_item.draft_content, dict) else {}
|
||
project = world_model.get("project") if isinstance(world_model.get("project"), dict) else {}
|
||
project_title = str(project.get("title") or project.get("name") or "未指定项目").strip() or "未指定项目"
|
||
project_description = str(project.get("description") or "").strip() or "暂无项目描述"
|
||
active_projects = self._normalize_active_projects(world_model.get("active_projects"))
|
||
similar_project_candidates = self._build_similar_project_candidates(
|
||
project_title=project_title,
|
||
project_description=project_description,
|
||
message_text=str(message_text or ""),
|
||
active_projects=active_projects,
|
||
)
|
||
|
||
members = await self._load_members(world_model=world_model)
|
||
recent_signals = self._normalize_recent_signals(world_model.get("recent_signals"))
|
||
revision_context = self._compose_revision_context(
|
||
revision_note=revision_note,
|
||
previous_draft=previous_draft,
|
||
)
|
||
prompt = PROMPT_DRAFT_GENERATOR.format(
|
||
project_title=project_title,
|
||
project_description=project_description,
|
||
active_projects_json=json.dumps(active_projects, ensure_ascii=False),
|
||
similar_project_candidates_json=json.dumps(similar_project_candidates, ensure_ascii=False),
|
||
members_json=json.dumps(members, ensure_ascii=False),
|
||
recent_signals=json.dumps(recent_signals, ensure_ascii=False),
|
||
user_message=str(message_text or "")[:2000],
|
||
intent_name=str(intent_name or "")[:64],
|
||
revision_note=str(revision_context or "")[:2500],
|
||
).strip()
|
||
|
||
payload = await self._generate_draft_payload(
|
||
prompt=prompt,
|
||
is_revision=bool(str(revision_note or "").strip()),
|
||
)
|
||
draft = self._normalize_draft_payload(
|
||
payload=payload,
|
||
members=members,
|
||
active_projects=active_projects,
|
||
similar_project_candidates=similar_project_candidates,
|
||
original_text=message_text,
|
||
version=next_version,
|
||
)
|
||
if revision_note and previous_draft:
|
||
draft = self._preserve_previous_draft_on_revision_regression(
|
||
previous_draft=previous_draft,
|
||
candidate_draft=draft,
|
||
)
|
||
|
||
expires_at = now_cn_naive() + timedelta(hours=_DRAFT_TIMEOUT_HOURS)
|
||
work_item.draft_content = draft
|
||
work_item.draft_version = next_version
|
||
work_item.draft_expires_at = expires_at
|
||
work_item.confirm_message_id = None
|
||
|
||
existing_execution = work_item.execution_result if isinstance(work_item.execution_result, dict) else {}
|
||
work_item.execution_result = {
|
||
**existing_execution,
|
||
"status": "draft_pending_confirm",
|
||
"draft": draft,
|
||
"draft_version": next_version,
|
||
"draft_expires_at": expires_at.isoformat(),
|
||
"revision_note": str(revision_note or "")[:500] or None,
|
||
}
|
||
|
||
return {
|
||
"draft": draft,
|
||
"draft_text": self.render_draft_message(draft),
|
||
"draft_expires_at": expires_at,
|
||
"draft_version": next_version,
|
||
}
|
||
|
||
async def _generate_draft_payload(self, *, prompt: str, is_revision: bool = False) -> dict[str, Any]:
|
||
best_payload: dict[str, Any] = {}
|
||
best_richness = 0
|
||
for max_tokens in self._build_token_ladder(is_revision=is_revision):
|
||
try:
|
||
extraction = await asyncio.wait_for(
|
||
llm_service.generate_structured_object(
|
||
prompt,
|
||
db=self.db,
|
||
tenant_id=self.tenant_id,
|
||
function_name="draft_generator_v1",
|
||
use_prompt_profile=False,
|
||
temperature=0.0,
|
||
max_tokens=max_tokens,
|
||
response_mode="fast",
|
||
),
|
||
timeout=_DRAFT_GENERATOR_TIMEOUT_SECONDS,
|
||
)
|
||
except Exception as exc:
|
||
logger.warning(
|
||
"draft_generator_llm_failed",
|
||
tenant_id=self.tenant_id,
|
||
max_tokens=max_tokens,
|
||
error=str(exc),
|
||
)
|
||
if self._looks_like_provider_budget_rejection(exc):
|
||
break
|
||
continue
|
||
payload = extraction.payload if extraction is not None and isinstance(extraction.payload, dict) else {}
|
||
recovered_payload = await self._recover_payload_from_logged_response(
|
||
prompt=prompt,
|
||
current_payload=payload,
|
||
)
|
||
candidate_payload = recovered_payload if isinstance(recovered_payload, dict) else payload
|
||
candidate_richness = self._payload_richness(candidate_payload)
|
||
if candidate_richness > best_richness:
|
||
best_payload = candidate_payload
|
||
best_richness = candidate_richness
|
||
if self._is_substantive_draft_payload(candidate_payload):
|
||
return candidate_payload
|
||
return best_payload
|
||
|
||
@staticmethod
|
||
def _build_token_ladder(*, is_revision: bool = False) -> list[int]:
|
||
if is_revision:
|
||
budgets = [
|
||
4_000,
|
||
8_000,
|
||
16_000,
|
||
32_000,
|
||
64_000,
|
||
_DRAFT_GENERATOR_MAX_TOKENS,
|
||
]
|
||
else:
|
||
budgets = [
|
||
_DRAFT_GENERATOR_INITIAL_MAX_TOKENS,
|
||
4_000,
|
||
8_000,
|
||
16_000,
|
||
32_000,
|
||
64_000,
|
||
_DRAFT_GENERATOR_MAX_TOKENS,
|
||
]
|
||
ordered: list[int] = []
|
||
for item in budgets:
|
||
value = max(256, min(int(item), _DRAFT_GENERATOR_MAX_TOKENS))
|
||
if value not in ordered:
|
||
ordered.append(value)
|
||
return ordered
|
||
|
||
@staticmethod
|
||
def _looks_like_provider_budget_rejection(exc: Exception) -> bool:
|
||
lowered = str(exc or "").lower()
|
||
return "400 bad request" in lowered and any(
|
||
token in lowered
|
||
for token in (
|
||
"dashscope",
|
||
"max_tokens",
|
||
"context",
|
||
"token",
|
||
"length",
|
||
)
|
||
)
|
||
|
||
@classmethod
|
||
def _is_substantive_draft_payload(cls, payload: dict[str, Any]) -> bool:
|
||
if not isinstance(payload, dict):
|
||
return False
|
||
if cls._payload_richness(payload) < 80:
|
||
return False
|
||
title = str(payload.get("title") or "").strip()
|
||
if not title or title == _DEFAULT_DRAFT_TITLE:
|
||
return False
|
||
section_hits = 0
|
||
if str(payload.get("target_customers") or "").strip():
|
||
section_hits += 1
|
||
if isinstance(payload.get("core_pain_points"), list) and payload.get("core_pain_points"):
|
||
section_hits += 1
|
||
if cls._has_meaningful_list(payload.get("mvp_items"), placeholder=_DEFAULT_DRAFT_MVP_ITEMS):
|
||
section_hits += 1
|
||
if cls._has_meaningful_list(payload.get("team_setup")):
|
||
section_hits += 1
|
||
if cls._has_meaningful_list(payload.get("technical_architecture")):
|
||
section_hits += 1
|
||
validation_metrics = payload.get("validation_metrics") if isinstance(payload.get("validation_metrics"), dict) else {}
|
||
if any(isinstance(validation_metrics.get(key), list) and validation_metrics.get(key) for key in ("product", "market")):
|
||
section_hits += 1
|
||
return section_hits >= 3
|
||
|
||
@staticmethod
|
||
def _has_meaningful_list(value: Any, *, placeholder: Optional[list[Any]] = None) -> bool:
|
||
if not isinstance(value, list) or not value:
|
||
return False
|
||
normalized = json.dumps(value, ensure_ascii=False, sort_keys=True)
|
||
if placeholder is not None and normalized == json.dumps(placeholder, ensure_ascii=False, sort_keys=True):
|
||
return False
|
||
return True
|
||
|
||
@staticmethod
|
||
def _compose_revision_context(
|
||
*,
|
||
revision_note: Optional[str],
|
||
previous_draft: dict[str, Any],
|
||
) -> str:
|
||
note = str(revision_note or "").strip()
|
||
if not note:
|
||
return ""
|
||
if not previous_draft:
|
||
return note
|
||
revision_base = {
|
||
"title": previous_draft.get("title"),
|
||
"summary": previous_draft.get("summary"),
|
||
"positioning_one_liner": previous_draft.get("positioning_one_liner"),
|
||
"target_customers": previous_draft.get("target_customers"),
|
||
"core_pain_points": previous_draft.get("core_pain_points"),
|
||
"mvp_items": previous_draft.get("mvp_items"),
|
||
"mvp_phase_1": previous_draft.get("mvp_phase_1"),
|
||
"mvp_phase_2": previous_draft.get("mvp_phase_2"),
|
||
"technical_architecture": previous_draft.get("technical_architecture"),
|
||
"business_model": previous_draft.get("business_model"),
|
||
"validation_metrics": previous_draft.get("validation_metrics"),
|
||
"quick_start_suggestions": previous_draft.get("quick_start_suggestions"),
|
||
"team_setup": previous_draft.get("team_setup"),
|
||
"prospect_assessment": previous_draft.get("prospect_assessment"),
|
||
"requirement_items": previous_draft.get("requirement_items"),
|
||
"missing_info": previous_draft.get("missing_info"),
|
||
"feasibility": previous_draft.get("feasibility"),
|
||
}
|
||
previous_json = json.dumps(revision_base, ensure_ascii=False, separators=(",", ":"))
|
||
return (
|
||
"请基于上一版草稿增量修改，未提及字段尽量保留。\n"
|
||
f"上一版草稿JSON：{previous_json[:1800]}\n"
|
||
f"本轮修改意见：{note}"
|
||
)
|
||
|
||
@classmethod
|
||
def _preserve_previous_draft_on_revision_regression(
|
||
cls,
|
||
*,
|
||
previous_draft: dict[str, Any],
|
||
candidate_draft: dict[str, Any],
|
||
) -> dict[str, Any]:
|
||
if not isinstance(previous_draft, dict) or not isinstance(candidate_draft, dict):
|
||
return candidate_draft
|
||
merged = dict(candidate_draft)
|
||
for key, previous_value in previous_draft.items():
|
||
if key in {"version", "original_text"}:
|
||
continue
|
||
current_value = merged.get(key)
|
||
if cls._should_preserve_previous_value(key=key, current_value=current_value, previous_value=previous_value):
|
||
merged[key] = previous_value
|
||
return merged
|
||
|
||
@classmethod
|
||
def _should_preserve_previous_value(
|
||
cls,
|
||
*,
|
||
key: str,
|
||
current_value: Any,
|
||
previous_value: Any,
|
||
) -> bool:
|
||
if previous_value in (None, "", [], {}):
|
||
return False
|
||
if current_value in (None, "", [], {}):
|
||
return True
|
||
if key == "title":
|
||
return str(current_value or "").strip() == _DEFAULT_DRAFT_TITLE
|
||
if key == "mvp_items":
|
||
return not cls._has_meaningful_list(current_value, placeholder=_DEFAULT_DRAFT_MVP_ITEMS)
|
||
if key == "followup_plan":
|
||
return json.dumps(current_value, ensure_ascii=False, sort_keys=True) == json.dumps(
|
||
_DEFAULT_DRAFT_FOLLOWUP_PLAN,
|
||
ensure_ascii=False,
|
||
sort_keys=True,
|
||
)
|
||
if key == "feasibility_reason":
|
||
return str(current_value or "").strip() == _DEFAULT_DRAFT_FEASIBILITY_REASON
|
||
if key == "prospect_assessment":
|
||
return str(current_value or "").strip() == _DEFAULT_DRAFT_PROSPECT_ASSESSMENT
|
||
if key in {
|
||
"target_customers",
|
||
"core_pain_points",
|
||
"mvp_phase_1",
|
||
"mvp_phase_2",
|
||
"technical_architecture",
|
||
"business_model",
|
||
"validation_metrics",
|
||
"quick_start_suggestions",
|
||
"team_setup",
|
||
"requirement_items",
|
||
"similar_projects",
|
||
"missing_info",
|
||
}:
|
||
return not cls._payload_richness(current_value) or cls._payload_richness(current_value) < cls._payload_richness(previous_value)
|
||
return False
|
||
|
||
async def _recover_payload_from_logged_response(
|
||
self,
|
||
*,
|
||
prompt: str,
|
||
current_payload: dict[str, Any],
|
||
) -> dict[str, Any]:
|
||
if not hasattr(self.db, "execute"):
|
||
return current_payload
|
||
current_richness = self._payload_richness(current_payload)
|
||
try:
|
||
rows = (
|
||
await self.db.execute(
|
||
select(AICallLog.response)
|
||
.where(
|
||
and_(
|
||
AICallLog.tenant_id == int(self.tenant_id),
|
||
AICallLog.function_name == "draft_generator_v1",
|
||
AICallLog.prompt == str(prompt or "")[:8000],
|
||
)
|
||
)
|
||
.order_by(AICallLog.id.desc())
|
||
.limit(5)
|
||
)
|
||
).scalars().all()
|
||
except Exception as exc:
|
||
logger.warning(
|
||
"draft_generator_logged_response_lookup_failed",
|
||
tenant_id=self.tenant_id,
|
||
error=str(exc),
|
||
)
|
||
return current_payload
|
||
|
||
best_payload = current_payload
|
||
best_richness = current_richness
|
||
for response_text in rows:
|
||
logged_payload = self._parse_logged_draft_payload(response_text)
|
||
logged_richness = self._payload_richness(logged_payload)
|
||
if logged_richness > best_richness:
|
||
best_payload = logged_payload
|
||
best_richness = logged_richness
|
||
return best_payload
|
||
|
||
@staticmethod
|
||
def _parse_logged_draft_payload(response_text: Any) -> dict[str, Any]:
|
||
text = str(response_text or "").strip()
|
||
if not text:
|
||
return {}
|
||
normalized = llm_service._strip_code_fence(text)
|
||
if not llm_service._looks_like_json_container(normalized):
|
||
return {}
|
||
candidate = llm_service._extract_json_candidate(normalized)
|
||
if not candidate:
|
||
return {}
|
||
try:
|
||
parsed: Any = json.loads(candidate)
|
||
except Exception:
|
||
return {}
|
||
parsed = llm_service._unwrap_structured_payload_once(parsed)
|
||
parsed = llm_service._coerce_structured_payload(
|
||
function_name="draft_generator_v1",
|
||
payload=parsed,
|
||
)
|
||
return parsed if isinstance(parsed, dict) else {}
|
||
|
||
@classmethod
|
||
def _payload_richness(cls, payload: Any) -> int:
|
||
if isinstance(payload, dict):
|
||
score = 0
|
||
for key, value in payload.items():
|
||
if str(key or "").strip():
|
||
score += 1
|
||
score += cls._payload_richness(value)
|
||
return score
|
||
if isinstance(payload, list):
|
||
return len(payload) + sum(cls._payload_richness(item) for item in payload)
|
||
if isinstance(payload, str):
|
||
return len(str(payload).strip())
|
||
if isinstance(payload, (int, float)) and not isinstance(payload, bool):
|
||
return 1
|
||
if isinstance(payload, bool):
|
||
return 1
|
||
return 0
|
||
|
||
async def _load_members(self, *, world_model: dict[str, Any]) -> list[dict[str, Any]]:
|
||
capacity = world_model.get("capacity") if isinstance(world_model.get("capacity"), list) else []
|
||
workload_map: dict[int, float] = {}
|
||
for row in capacity:
|
||
if not isinstance(row, dict):
|
||
continue
|
||
user_id = self._safe_int(row.get("user_id"))
|
||
if user_id is None:
|
||
continue
|
||
ratio = self._safe_float(row.get("workload_ratio"))
|
||
workload_map[user_id] = max(0.0, min(100.0, ratio * 100.0))
|
||
|
||
user_ids = sorted(workload_map.keys())
|
||
if user_ids:
|
||
rows = (
|
||
await self.db.execute(
|
||
select(User.id, User.name, User.username)
|
||
.where(
|
||
and_(
|
||
User.tenant_id == int(self.tenant_id),
|
||
User.id.in_(user_ids),
|
||
User.is_active.is_(True),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
members = [
|
||
{
|
||
"id": int(row.id),
|
||
"name": str(row.name or row.username or f"成员#{int(row.id)}").strip()[:40],
|
||
"workload_percent": round(float(workload_map.get(int(row.id), 0.0)), 1),
|
||
}
|
||
for row in rows
|
||
]
|
||
members.sort(key=lambda item: (float(item.get("workload_percent") or 0.0), int(item.get("id") or 0)))
|
||
return members[:20]
|
||
|
||
rows = (
|
||
await self.db.execute(
|
||
select(User.id, User.name, User.username, UserWorkload.workload_ratio)
|
||
.outerjoin(
|
||
UserWorkload,
|
||
and_(
|
||
UserWorkload.tenant_id == User.tenant_id,
|
||
UserWorkload.user_id == User.id,
|
||
),
|
||
)
|
||
.where(
|
||
and_(
|
||
User.tenant_id == int(self.tenant_id),
|
||
User.is_active.is_(True),
|
||
)
|
||
)
|
||
.order_by(User.id.asc())
|
||
.limit(20)
|
||
)
|
||
).all()
|
||
members = []
|
||
for row in rows:
|
||
members.append(
|
||
{
|
||
"id": int(row.id),
|
||
"name": str(row.name or row.username or f"成员#{int(row.id)}").strip()[:40],
|
||
"workload_percent": round(max(0.0, min(100.0, self._safe_float(row.workload_ratio) * 100.0)), 1),
|
||
}
|
||
)
|
||
members.sort(key=lambda item: (float(item.get("workload_percent") or 0.0), int(item.get("id") or 0)))
|
||
return members
|
||
|
||
@staticmethod
|
||
def _normalize_recent_signals(value: Any) -> list[dict[str, Any]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, Any]] = []
|
||
for row in value[:8]:
|
||
if not isinstance(row, dict):
|
||
continue
|
||
normalized.append(
|
||
{
|
||
"id": DraftGeneratorService._safe_int(row.get("id")),
|
||
"title": str(row.get("title") or "").strip()[:80],
|
||
"type": str(row.get("signal_type") or "").strip()[:30],
|
||
"status": str(row.get("status") or "").strip()[:20],
|
||
}
|
||
)
|
||
return normalized
|
||
|
||
def _normalize_draft_payload(
|
||
self,
|
||
*,
|
||
payload: dict[str, Any],
|
||
members: list[dict[str, Any]],
|
||
active_projects: list[dict[str, Any]],
|
||
similar_project_candidates: list[dict[str, Any]],
|
||
original_text: str,
|
||
version: int,
|
||
) -> dict[str, Any]:
|
||
title = self._normalize_title(str(payload.get("title") or ""))
|
||
summary = self._normalize_summary(str(payload.get("summary") or ""), fallback_text=original_text)
|
||
|
||
feasibility = str(payload.get("feasibility") or "").strip()
|
||
if feasibility not in _FEASIBILITY_ALLOWED:
|
||
feasibility = "待讨论"
|
||
feasibility_reason = str(payload.get("feasibility_reason") or "").strip()[:30]
|
||
if not feasibility_reason:
|
||
feasibility_reason = "信息仍需补充，建议先确认边界。"
|
||
|
||
assignee_map = {
|
||
int(item.get("id") or 0): item
|
||
for item in members
|
||
if self._safe_int(item.get("id")) is not None
|
||
}
|
||
assignee_id = self._safe_int(payload.get("recommended_assignee_id"))
|
||
if assignee_id is None or assignee_id not in assignee_map:
|
||
assignee_id = int(members[0]["id"]) if members else None
|
||
assignee = assignee_map.get(assignee_id) if assignee_id is not None else None
|
||
assignee_reason = str(payload.get("recommended_assignee_reason") or "").strip()[:80]
|
||
if not assignee_reason:
|
||
assignee_reason = "基于当前负载与任务匹配度给出的建议。"
|
||
|
||
similar_projects = self._normalize_similar_projects(
|
||
payload.get("similar_projects"),
|
||
fallback_candidates=similar_project_candidates,
|
||
active_projects=active_projects,
|
||
original_text=original_text,
|
||
title=title,
|
||
)
|
||
mvp_items = self._normalize_string_list(
|
||
payload.get("mvp_items"),
|
||
fallback=[
|
||
"明确项目目标与边界",
|
||
"完成同名/相似项目查重",
|
||
"交付最小可验证闭环",
|
||
],
|
||
max_items=5,
|
||
max_length=80,
|
||
)
|
||
prospect_assessment = str(payload.get("prospect_assessment") or "").strip()[:240]
|
||
if not prospect_assessment:
|
||
prospect_assessment = "该项目具备落地价值，但建议先确认范围边界和现有项目复用情况，再决定是否推进。"
|
||
requirement_items = self._normalize_string_list(
|
||
payload.get("requirement_items"),
|
||
fallback=[
|
||
"项目定位与目标",
|
||
"MVP 功能范围",
|
||
"需求边界与验收标准",
|
||
],
|
||
max_items=8,
|
||
max_length=100,
|
||
)
|
||
missing_info = self._normalize_string_list(
|
||
payload.get("missing_info"),
|
||
fallback=[],
|
||
max_items=5,
|
||
max_length=80,
|
||
)
|
||
followup_plan = self._normalize_followup_plan(payload.get("followup_plan"))
|
||
if not followup_plan:
|
||
followup_plan = [
|
||
{"when": "明天", "action": "确认触发时机与验收口径"},
|
||
{"when": "一周后", "action": "复核执行效果并决定是否扩展"},
|
||
]
|
||
positioning_one_liner = str(
|
||
payload.get("positioning_one_liner")
|
||
or payload.get("positioning")
|
||
or ""
|
||
).strip()[:160]
|
||
target_customers = str(payload.get("target_customers") or "").strip()[:160]
|
||
core_pain_points = self._normalize_core_pain_points(payload.get("core_pain_points"))
|
||
mvp_phase_1, mvp_phase_2 = self._normalize_mvp_phases(payload)
|
||
technical_architecture = self._normalize_string_list(
|
||
payload.get("technical_architecture"),
|
||
fallback=[],
|
||
max_items=6,
|
||
max_length=100,
|
||
)
|
||
business_model = self._normalize_business_model_items(payload.get("business_model"))
|
||
validation_metrics = self._normalize_section_map(
|
||
payload.get("validation_metrics"),
|
||
keys=("product", "market"),
|
||
)
|
||
quick_start_suggestions = self._normalize_section_map(
|
||
payload.get("quick_start_suggestions"),
|
||
keys=("week_1_2", "week_3_4"),
|
||
)
|
||
team_setup = self._normalize_team_setup_items(payload.get("team_setup"))
|
||
requirement_items = self._normalize_requirement_items(
|
||
payload.get("requirement_items"),
|
||
core_pain_points=core_pain_points,
|
||
mvp_phase_1=mvp_phase_1,
|
||
mvp_phase_2=mvp_phase_2,
|
||
technical_architecture=technical_architecture,
|
||
business_model=business_model,
|
||
validation_metrics=validation_metrics,
|
||
quick_start_suggestions=quick_start_suggestions,
|
||
team_setup=team_setup,
|
||
default_source_kind="custom",
|
||
)
|
||
|
||
workload = 0.0
|
||
if assignee is not None:
|
||
workload = float(assignee.get("workload_percent") or 0.0)
|
||
|
||
return {
|
||
"title": title,
|
||
"summary": summary,
|
||
"positioning_one_liner": positioning_one_liner or summary,
|
||
"target_customers": target_customers,
|
||
"similar_projects": similar_projects,
|
||
"mvp_items": mvp_items,
|
||
"core_pain_points": core_pain_points,
|
||
"mvp_phase_1": mvp_phase_1,
|
||
"mvp_phase_2": mvp_phase_2,
|
||
"technical_architecture": technical_architecture,
|
||
"business_model": business_model,
|
||
"validation_metrics": validation_metrics,
|
||
"quick_start_suggestions": quick_start_suggestions,
|
||
"team_setup": team_setup,
|
||
"prospect_assessment": prospect_assessment,
|
||
"requirement_items": requirement_items,
|
||
"missing_info": missing_info,
|
||
"feasibility": feasibility,
|
||
"feasibility_reason": feasibility_reason,
|
||
"recommended_assignee_id": assignee_id,
|
||
"recommended_assignee_name": str((assignee or {}).get("name") or "待指定").strip()[:40] or "待指定",
|
||
"recommended_assignee_workload": round(max(0.0, min(100.0, workload)), 1),
|
||
"recommended_assignee_reason": assignee_reason,
|
||
"followup_plan": followup_plan,
|
||
"original_text": str(original_text or "")[:2000],
|
||
"version": int(version),
|
||
}
|
||
|
||
@staticmethod
|
||
def render_draft_message(draft: dict[str, Any]) -> str:
|
||
title = str(draft.get("title") or "未命名需求").strip() or "未命名需求"
|
||
summary = str(draft.get("summary") or "暂无摘要").strip() or "暂无摘要"
|
||
similar_projects = draft.get("similar_projects") if isinstance(draft.get("similar_projects"), list) else []
|
||
mvp_items = draft.get("mvp_items") if isinstance(draft.get("mvp_items"), list) else []
|
||
positioning_one_liner = str(draft.get("positioning_one_liner") or summary).strip() or summary
|
||
target_customers = str(draft.get("target_customers") or "").strip() or "待补充"
|
||
core_pain_points = draft.get("core_pain_points") if isinstance(draft.get("core_pain_points"), list) else []
|
||
mvp_phase_1 = draft.get("mvp_phase_1") if isinstance(draft.get("mvp_phase_1"), list) else []
|
||
mvp_phase_2 = draft.get("mvp_phase_2") if isinstance(draft.get("mvp_phase_2"), list) else []
|
||
technical_architecture = draft.get("technical_architecture") if isinstance(draft.get("technical_architecture"), list) else []
|
||
business_model = draft.get("business_model") if isinstance(draft.get("business_model"), list) else []
|
||
validation_metrics = draft.get("validation_metrics") if isinstance(draft.get("validation_metrics"), dict) else {}
|
||
quick_start_suggestions = draft.get("quick_start_suggestions") if isinstance(draft.get("quick_start_suggestions"), dict) else {}
|
||
team_setup = draft.get("team_setup") if isinstance(draft.get("team_setup"), list) else []
|
||
prospect_assessment = str(draft.get("prospect_assessment") or "").strip()
|
||
requirement_items = draft.get("requirement_items") if isinstance(draft.get("requirement_items"), list) else []
|
||
missing_info = draft.get("missing_info") if isinstance(draft.get("missing_info"), list) else []
|
||
feasibility = str(draft.get("feasibility") or "待讨论").strip() or "待讨论"
|
||
feasibility_reason = str(draft.get("feasibility_reason") or "").strip()
|
||
assignee_name = str(draft.get("recommended_assignee_name") or "待指定").strip() or "待指定"
|
||
assignee_workload = DraftGeneratorService._safe_float(draft.get("recommended_assignee_workload"))
|
||
assignee_reason = str(draft.get("recommended_assignee_reason") or "").strip()
|
||
plan = draft.get("followup_plan") if isinstance(draft.get("followup_plan"), list) else []
|
||
|
||
plan_lines: list[str] = []
|
||
for row in plan[:2]:
|
||
if not isinstance(row, dict):
|
||
continue
|
||
when = str(row.get("when") or "待定").strip()[:20] or "待定"
|
||
action = str(row.get("action") or "补充执行动作").strip()[:80] or "补充执行动作"
|
||
plan_lines.append(f"· {when}：{action}")
|
||
if not plan_lines:
|
||
plan_lines = ["· 待定：补充跟进计划"]
|
||
|
||
if not mvp_phase_1 and mvp_items:
|
||
mvp_phase_1 = mvp_items[:3]
|
||
if not mvp_phase_2 and len(mvp_items) > 3:
|
||
mvp_phase_2 = mvp_items[3:6]
|
||
|
||
def _format_text_items(items: list[Any], *, default_line: str, max_items: int = 4) -> list[str]:
|
||
lines = DraftGeneratorService._render_bullet_items(
|
||
items,
|
||
default_line=default_line,
|
||
formatter=DraftGeneratorService._render_text_item_line,
|
||
max_items=max_items,
|
||
)
|
||
return lines
|
||
|
||
def _format_pain_point_table(items: list[Any]) -> list[str]:
|
||
rows: list[list[str]] = []
|
||
for item in items[:3]:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
pain = str(item.get("pain") or "").strip()[:40]
|
||
status = str(item.get("status") or "").strip()[:60] or "待补充"
|
||
opportunity = str(item.get("opportunity") or "").strip()[:60] or "待补充"
|
||
if pain:
|
||
rows.append([pain, status, opportunity])
|
||
if not rows:
|
||
return []
|
||
lines = [
|
||
"痛点 | 现状 | 机会",
|
||
"---|---|---",
|
||
]
|
||
for pain, status, opportunity in rows:
|
||
lines.append(f"{pain} | {status} | {opportunity}")
|
||
return lines
|
||
|
||
def _format_business_model_lines(items: list[Any]) -> list[str]:
|
||
rows: list[str] = []
|
||
for item in items[:3]:
|
||
if not isinstance(item, dict):
|
||
text = str(item or "").strip()
|
||
if text:
|
||
rows.append(f"· {text[:120]}")
|
||
continue
|
||
plan_name = str(item.get("plan") or item.get("name") or "").strip()[:40]
|
||
price = str(item.get("price") or "").strip()[:40] or "待定"
|
||
features = str(item.get("features") or item.get("value") or "").strip()[:120] or "待补充"
|
||
if plan_name:
|
||
rows.append(f"· {plan_name}：{price}；{features}")
|
||
if not rows:
|
||
rows = ["· 待补充商业模式"]
|
||
return rows
|
||
|
||
def _format_section_map_lines(title_text: str, section_map: dict[str, Any], keys: tuple[str, ...]) -> list[str]:
|
||
lines: list[str] = [title_text]
|
||
has_any = False
|
||
for key in keys:
|
||
values = section_map.get(key) if isinstance(section_map.get(key), list) else []
|
||
if not values:
|
||
continue
|
||
has_any = True
|
||
label = {
|
||
"product": "产品验证",
|
||
"market": "市场验证",
|
||
"week_1_2": "Week 1-2",
|
||
"week_3_4": "Week 3-4",
|
||
}.get(key, key)
|
||
lines.append(f"{label}：")
|
||
lines.extend(_format_text_items(values, default_line="· 待补充", max_items=3))
|
||
if not has_any:
|
||
lines.append("· 待补充")
|
||
return lines
|
||
|
||
def _format_team_lines(items: list[Any]) -> list[str]:
|
||
rows: list[str] = []
|
||
for item in items[:5]:
|
||
if not isinstance(item, dict):
|
||
text = str(item or "").strip()
|
||
if text:
|
||
rows.append(f"· {text[:120]}")
|
||
continue
|
||
role = str(item.get("role") or item.get("title") or item.get("name") or "").strip()[:60]
|
||
notes = str(item.get("notes") or item.get("description") or "").strip()[:120] or "待补充"
|
||
if role:
|
||
rows.append(f"· {role}：{notes}")
|
||
if not rows:
|
||
rows = ["· 待补充团队配置"]
|
||
return rows
|
||
|
||
pain_table_lines = _format_pain_point_table(core_pain_points)
|
||
if not pain_table_lines:
|
||
requirement_pain_items = [
|
||
item
|
||
for item in requirement_items
|
||
if isinstance(item, dict) and str(item.get("section") or "").strip() == "核心痛点"
|
||
]
|
||
pain_table_lines = _format_pain_point_table(
|
||
[
|
||
{
|
||
"pain": str(item.get("title") or "").strip(),
|
||
"status": str(item.get("description") or "").strip(),
|
||
"opportunity": "",
|
||
}
|
||
for item in requirement_pain_items
|
||
]
|
||
)
|
||
if not pain_table_lines:
|
||
pain_table_lines = ["· 待补充核心痛点"]
|
||
|
||
phase_1_lines = _format_text_items(
|
||
mvp_phase_1,
|
||
default_line="· 待补充：先明确核心闭环",
|
||
max_items=4,
|
||
)
|
||
phase_2_lines = _format_text_items(
|
||
mvp_phase_2,
|
||
default_line="· 待补充：确认差异化方向后再展开",
|
||
max_items=3,
|
||
)
|
||
tech_lines = _format_text_items(
|
||
technical_architecture,
|
||
default_line="· 待补充技术架构",
|
||
max_items=6,
|
||
)
|
||
business_lines = _format_business_model_lines(business_model)
|
||
validation_lines = _format_section_map_lines(
|
||
"验证指标：",
|
||
validation_metrics,
|
||
keys=("product", "market"),
|
||
)
|
||
quick_start_lines = _format_section_map_lines(
|
||
"快速启动建议：",
|
||
quick_start_suggestions,
|
||
keys=("week_1_2", "week_3_4"),
|
||
)
|
||
team_lines = _format_team_lines(team_setup)
|
||
|
||
workload_text = f"{assignee_workload:.1f}" if assignee_workload % 1 else f"{int(assignee_workload)}"
|
||
feasibility_reason_line = feasibility_reason if feasibility_reason else "需补充约束后再确认。"
|
||
assignee_reason_line = assignee_reason if assignee_reason else "建议结合成员技能与当前负载综合判断。"
|
||
similar_lines = DraftGeneratorService._render_bullet_items(
|
||
similar_projects,
|
||
default_line="· 未发现同名或高相似项目，可作为新立项继续评审。",
|
||
formatter=DraftGeneratorService._render_similar_project_line,
|
||
max_items=3,
|
||
)
|
||
mvp_lines = DraftGeneratorService._render_bullet_items(
|
||
mvp_items,
|
||
default_line="· 待定：先明确目标后补齐 MVP 范围",
|
||
formatter=DraftGeneratorService._render_text_item_line,
|
||
max_items=5,
|
||
)
|
||
requirement_lines = DraftGeneratorService._render_bullet_items(
|
||
requirement_items,
|
||
default_line="· 待定：补充需求清单",
|
||
formatter=DraftGeneratorService._render_text_item_line,
|
||
max_items=8,
|
||
)
|
||
missing_info_lines = DraftGeneratorService._render_bullet_items(
|
||
missing_info,
|
||
default_line="· 暂无",
|
||
formatter=DraftGeneratorService._render_text_item_line,
|
||
max_items=5,
|
||
)
|
||
prospect_lines = DraftGeneratorService._split_paragraph_lines(
|
||
prospect_assessment or "该项目前景尚可，但建议先确认范围边界。"
|
||
)
|
||
current_judgement_lines = [
|
||
f"可行性：{feasibility}",
|
||
feasibility_reason_line,
|
||
*prospect_lines[:1],
|
||
]
|
||
implementation_reference_lines = [
|
||
*tech_lines[:2],
|
||
*business_lines[:1],
|
||
*team_lines[:2],
|
||
]
|
||
return "\n".join(
|
||
[
|
||
"📋 已为你起草需求，请确认：",
|
||
"",
|
||
f"📌 {title}",
|
||
summary,
|
||
"",
|
||
"🔎 相似项目",
|
||
*similar_lines,
|
||
"",
|
||
"🚀 建议先做",
|
||
*mvp_lines[:3],
|
||
f"· 定位：{positioning_one_liner}",
|
||
f"· 目标客户：{target_customers}",
|
||
"",
|
||
"✅ 当前判断",
|
||
*current_judgement_lines,
|
||
"",
|
||
"⚠️ 仍需确认",
|
||
*missing_info_lines,
|
||
*requirement_lines[:2],
|
||
"",
|
||
"🧱 实施参考",
|
||
*implementation_reference_lines,
|
||
"",
|
||
"👤 推荐负责人",
|
||
f"{assignee_name} · 当前负载{workload_text}%",
|
||
assignee_reason_line,
|
||
"",
|
||
"📅 下一步",
|
||
*plan_lines,
|
||
"",
|
||
"---",
|
||
"回复 确认 → 入库",
|
||
"回复 修改 [具体修改意见] → 重新起草",
|
||
"回复 取消 → 放弃",
|
||
"⏰ 24小时内未确认自动取消",
|
||
]
|
||
)
|
||
|
||
@staticmethod
|
||
def _normalize_title(raw_title: str) -> str:
|
||
title = str(raw_title or "").strip()
|
||
if not title:
|
||
return "需求草稿"
|
||
return title[:20]
|
||
|
||
@staticmethod
|
||
def _normalize_summary(raw_summary: str, *, fallback_text: str) -> str:
|
||
summary = " ".join(str(raw_summary or "").split()).strip()
|
||
if not summary:
|
||
summary = " ".join(str(fallback_text or "").split()).strip()
|
||
if not summary:
|
||
summary = "请确认该需求是否需要立即入库。"
|
||
return summary[:80]
|
||
|
||
@staticmethod
|
||
def _normalize_followup_plan(value: Any) -> list[dict[str, str]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, str]] = []
|
||
for row in value[:3]:
|
||
if not isinstance(row, dict):
|
||
continue
|
||
when = str(row.get("when") or "").strip()[:20]
|
||
action = str(row.get("action") or "").strip()[:80]
|
||
if not when or not action:
|
||
continue
|
||
normalized.append({"when": when, "action": action})
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalize_core_pain_points(value: Any) -> list[dict[str, str]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, str]] = []
|
||
for row in value[:5]:
|
||
if isinstance(row, dict):
|
||
pain = ""
|
||
for key in ("pain", "title", "name"):
|
||
candidate = str(row.get(key) or "").strip()
|
||
if candidate:
|
||
pain = candidate[:80]
|
||
break
|
||
if not pain:
|
||
pain = " ".join(str(row.get("value") or "").split()).strip()[:80]
|
||
if not pain:
|
||
continue
|
||
normalized.append(
|
||
{
|
||
"pain": pain,
|
||
"status": str(row.get("status") or row.get("current_status") or "").strip()[:120],
|
||
"opportunity": str(row.get("opportunity") or row.get("chance") or "").strip()[:120],
|
||
}
|
||
)
|
||
elif isinstance(row, str):
|
||
pain = " ".join(row.split()).strip()[:80]
|
||
if pain:
|
||
normalized.append({"pain": pain, "status": "", "opportunity": ""})
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalize_business_model_items(value: Any) -> list[dict[str, str]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, str]] = []
|
||
for row in value[:5]:
|
||
if isinstance(row, dict):
|
||
plan = ""
|
||
for key in ("plan", "name"):
|
||
candidate = str(row.get(key) or "").strip()
|
||
if candidate:
|
||
plan = candidate[:40]
|
||
break
|
||
price = str(row.get("price") or "").strip()[:40]
|
||
features = ""
|
||
for key in ("features", "value"):
|
||
candidate = str(row.get(key) or "").strip()
|
||
if candidate:
|
||
features = candidate[:160]
|
||
break
|
||
if not any((plan, price, features)):
|
||
continue
|
||
normalized.append({"plan": plan, "price": price, "features": features})
|
||
elif isinstance(row, str):
|
||
text = " ".join(row.split()).strip()[:120]
|
||
if text:
|
||
normalized.append({"plan": text, "price": "", "features": ""})
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalize_section_map(value: Any, *, keys: tuple[str, ...]) -> dict[str, list[str]]:
|
||
result = {key: [] for key in keys}
|
||
if not isinstance(value, dict):
|
||
return result
|
||
for key in keys:
|
||
result[key] = DraftGeneratorService._normalize_string_list(
|
||
value.get(key),
|
||
fallback=[],
|
||
max_items=5,
|
||
max_length=120,
|
||
)
|
||
return result
|
||
|
||
@staticmethod
|
||
def _normalize_team_setup_items(value: Any) -> list[dict[str, str]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, str]] = []
|
||
for row in value[:6]:
|
||
if isinstance(row, dict):
|
||
role = ""
|
||
for key in ("role", "title", "name"):
|
||
candidate = str(row.get(key) or "").strip()
|
||
if candidate:
|
||
role = candidate[:60]
|
||
break
|
||
notes = ""
|
||
for key in ("notes", "description"):
|
||
candidate = str(row.get(key) or "").strip()
|
||
if candidate:
|
||
notes = candidate[:120]
|
||
break
|
||
if not any((role, notes)):
|
||
continue
|
||
normalized.append({"role": role, "notes": notes})
|
||
elif isinstance(row, str):
|
||
text = " ".join(row.split()).strip()[:120]
|
||
if text:
|
||
normalized.append({"role": text, "notes": ""})
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalize_mvp_phases(payload: dict[str, Any]) -> tuple[list[str], list[str]]:
|
||
mvp_phases = payload.get("mvp_phases") if isinstance(payload.get("mvp_phases"), dict) else {}
|
||
phase_1 = DraftGeneratorService._normalize_string_list(
|
||
payload.get("mvp_phase_1") or payload.get("phase_1") or mvp_phases.get("phase_1") or mvp_phases.get("week_1_4"),
|
||
fallback=[],
|
||
max_items=5,
|
||
max_length=100,
|
||
)
|
||
phase_2 = DraftGeneratorService._normalize_string_list(
|
||
payload.get("mvp_phase_2") or payload.get("phase_2") or mvp_phases.get("phase_2") or mvp_phases.get("week_5_8"),
|
||
fallback=[],
|
||
max_items=5,
|
||
max_length=100,
|
||
)
|
||
return phase_1, phase_2
|
||
|
||
@staticmethod
|
||
def _normalize_requirement_items(
|
||
requirement_items: Any,
|
||
*,
|
||
core_pain_points: list[dict[str, str]],
|
||
mvp_phase_1: list[str],
|
||
mvp_phase_2: list[str],
|
||
technical_architecture: list[str],
|
||
business_model: list[dict[str, str]],
|
||
validation_metrics: dict[str, list[str]],
|
||
quick_start_suggestions: dict[str, list[str]],
|
||
team_setup: list[dict[str, str]],
|
||
default_source_kind: str,
|
||
) -> list[dict[str, Any]]:
|
||
normalized: list[dict[str, Any]] = []
|
||
if isinstance(requirement_items, list):
|
||
for raw_item in requirement_items:
|
||
if not isinstance(raw_item, dict):
|
||
continue
|
||
section = str(raw_item.get("section") or raw_item.get("category") or "").strip()[:40] or "MVP 功能"
|
||
title = str(raw_item.get("title") or raw_item.get("name") or raw_item.get("feature") or "").strip()[:120]
|
||
description = str(raw_item.get("description") or raw_item.get("summary") or title).strip()[:600]
|
||
if not title:
|
||
continue
|
||
normalized.append(
|
||
{
|
||
"section": section,
|
||
"title": title,
|
||
"description": description or title,
|
||
"priority": str(raw_item.get("priority") or "medium").strip().lower() or "medium",
|
||
"source_kind": str(raw_item.get("source_kind") or default_source_kind).strip() or default_source_kind,
|
||
"source_name": str(raw_item.get("source_name") or f"{section} - {title}").strip()[:120],
|
||
"source_identifier": str(raw_item.get("source_identifier") or "").strip()[:180],
|
||
}
|
||
)
|
||
if normalized:
|
||
return normalized[:8]
|
||
|
||
derived: list[dict[str, Any]] = []
|
||
for point in core_pain_points[:3]:
|
||
title = str(point.get("pain") or "").strip()[:120]
|
||
if not title:
|
||
continue
|
||
description_parts: list[str] = []
|
||
status_text = str(point.get("status") or "").strip()[:120]
|
||
if status_text:
|
||
description_parts.append(f"现状：{status_text}")
|
||
opportunity_text = str(point.get("opportunity") or "").strip()[:120]
|
||
if opportunity_text:
|
||
description_parts.append(f"机会：{opportunity_text}")
|
||
derived.append(
|
||
{
|
||
"section": "核心痛点",
|
||
"title": title,
|
||
"description": "；".join(description_parts) or title,
|
||
"priority": "high",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"核心痛点 - {title}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for item in mvp_phase_1[:3]:
|
||
if not item:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "MVP 功能",
|
||
"title": item[:120],
|
||
"description": item[:600],
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"MVP 功能 - {item}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for item in mvp_phase_2[:3]:
|
||
if not item:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "差异化功能",
|
||
"title": item[:120],
|
||
"description": item[:600],
|
||
"priority": "low",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"差异化功能 - {item}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for item in technical_architecture[:3]:
|
||
if not item:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "技术架构",
|
||
"title": item[:120],
|
||
"description": item[:600],
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"技术架构 - {item}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for row in business_model[:3]:
|
||
title = str(row.get("plan") or row.get("price") or "").strip()[:120]
|
||
features = str(row.get("features") or "").strip()[:600]
|
||
if not title:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "商业模式",
|
||
"title": title,
|
||
"description": features or title,
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"商业模式 - {title}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for metric in validation_metrics.get("product", [])[:3]:
|
||
if not metric:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "验证指标",
|
||
"title": metric[:120],
|
||
"description": metric[:600],
|
||
"priority": "low",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"验证指标 - {metric}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for metric in validation_metrics.get("market", [])[:3]:
|
||
if not metric:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "市场验证",
|
||
"title": metric[:120],
|
||
"description": metric[:600],
|
||
"priority": "low",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"市场验证 - {metric}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for key, rows in quick_start_suggestions.items():
|
||
section = "快速启动建议"
|
||
for item in rows[:2]:
|
||
if not item:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": section,
|
||
"title": item[:120],
|
||
"description": item[:600],
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"{section} - {item}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
for row in team_setup[:4]:
|
||
title = str(row.get("role") or "").strip()[:120]
|
||
notes = str(row.get("notes") or "").strip()[:600]
|
||
if not title:
|
||
continue
|
||
derived.append(
|
||
{
|
||
"section": "团队配置",
|
||
"title": title,
|
||
"description": notes or title,
|
||
"priority": "low",
|
||
"source_kind": default_source_kind,
|
||
"source_name": f"团队配置 - {title}"[:120],
|
||
"source_identifier": "",
|
||
}
|
||
)
|
||
if derived:
|
||
return derived[:8]
|
||
return [
|
||
{
|
||
"section": "项目定位",
|
||
"title": "项目定位与目标",
|
||
"description": "需确认项目定位与目标。",
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": "项目定位 - 项目定位与目标",
|
||
"source_identifier": "",
|
||
},
|
||
{
|
||
"section": "MVP 功能",
|
||
"title": "MVP 功能范围",
|
||
"description": "需确认 MVP 功能范围。",
|
||
"priority": "medium",
|
||
"source_kind": default_source_kind,
|
||
"source_name": "MVP 功能 - MVP 功能范围",
|
||
"source_identifier": "",
|
||
},
|
||
]
|
||
|
||
@staticmethod
|
||
def _normalize_active_projects(value: Any) -> list[dict[str, Any]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
normalized: list[dict[str, Any]] = []
|
||
for row in value[:20]:
|
||
if not isinstance(row, dict):
|
||
continue
|
||
project_id = DraftGeneratorService._safe_int(row.get("id"))
|
||
title = str(row.get("title") or row.get("name") or "").strip()[:120]
|
||
if project_id is None or not title:
|
||
continue
|
||
normalized.append(
|
||
{
|
||
"project_id": project_id,
|
||
"title": title,
|
||
"name": str(row.get("name") or title).strip()[:120],
|
||
"description": str(row.get("description") or "").strip()[:300],
|
||
"status": str(row.get("status") or "").strip()[:20],
|
||
}
|
||
)
|
||
return normalized
|
||
|
||
def _build_similar_project_candidates(
|
||
self,
|
||
*,
|
||
project_title: str,
|
||
project_description: str,
|
||
message_text: str,
|
||
active_projects: list[dict[str, Any]],
|
||
) -> list[dict[str, Any]]:
|
||
query = " ".join(
|
||
part
|
||
for part in [str(project_title or "").strip(), str(project_description or "").strip(), str(message_text or "").strip()]
|
||
if part
|
||
)
|
||
if not query:
|
||
return []
|
||
candidates: list[dict[str, Any]] = []
|
||
for row in active_projects:
|
||
project_id = self._safe_int(row.get("project_id"))
|
||
title = str(row.get("title") or row.get("name") or "").strip()
|
||
if project_id is None or not title:
|
||
continue
|
||
description = str(row.get("description") or "").strip()
|
||
candidate_text = f"{title} {description}".strip()
|
||
score = self._score_similarity(query, candidate_text)
|
||
if score < 0.22:
|
||
continue
|
||
reuse_suggestion = "建议先评估是否复用现有项目，避免重复建设。"
|
||
if score >= 0.55:
|
||
reuse_suggestion = "名称或目标高度接近，优先确认是否复用或合并。"
|
||
difference = "与当前需求主题接近，建议重点确认范围边界。"
|
||
if description and len(description) > 20:
|
||
difference = "现有项目已有一定描述，建议对比当前需求的目标、范围和交付边界。"
|
||
risk = "若范围重叠，可能造成重复建设或维护分散。"
|
||
candidates.append(
|
||
{
|
||
"project_id": project_id,
|
||
"title": title,
|
||
"difference": difference,
|
||
"risk": risk,
|
||
"reuse_suggestion": reuse_suggestion,
|
||
"match_score": round(min(score, 1.0), 3),
|
||
}
|
||
)
|
||
candidates.sort(key=lambda item: (-float(item.get("match_score") or 0.0), int(item.get("project_id") or 0)))
|
||
return candidates[:3]
|
||
|
||
@staticmethod
|
||
def _score_similarity(left: str, right: str) -> float:
|
||
left_norm = re.sub(r"\s+", "", str(left or "").lower())
|
||
right_norm = re.sub(r"\s+", "", str(right or "").lower())
|
||
if not left_norm or not right_norm:
|
||
return 0.0
|
||
base = SequenceMatcher(None, left_norm, right_norm).ratio()
|
||
if left_norm in right_norm or right_norm in left_norm:
|
||
base = max(base, 0.75)
|
||
shared = set(re.findall(r"[\u4e00-\u9fff]{2,}", left_norm)) & set(re.findall(r"[\u4e00-\u9fff]{2,}", right_norm))
|
||
if shared:
|
||
base = min(1.0, base + min(len(shared) * 0.08, 0.2))
|
||
return base
|
||
|
||
@staticmethod
|
||
def _normalize_similar_projects(
|
||
value: Any,
|
||
*,
|
||
fallback_candidates: list[dict[str, Any]],
|
||
active_projects: list[dict[str, Any]],
|
||
original_text: str,
|
||
title: str,
|
||
) -> list[dict[str, Any]]:
|
||
normalized: list[dict[str, Any]] = []
|
||
if isinstance(value, list):
|
||
for row in value[:5]:
|
||
if isinstance(row, dict):
|
||
project_id = DraftGeneratorService._safe_int(row.get("project_id") or row.get("id"))
|
||
project_title = str(row.get("title") or row.get("name") or "").strip()[:120]
|
||
if project_id is None or not project_title:
|
||
continue
|
||
normalized.append(
|
||
{
|
||
"project_id": project_id,
|
||
"title": project_title,
|
||
"difference": str(row.get("difference") or "").strip()[:160] or "需确认范围差异。",
|
||
"risk": str(row.get("risk") or "").strip()[:160] or "可能存在重复建设风险。",
|
||
"reuse_suggestion": str(row.get("reuse_suggestion") or row.get("suggestion") or "").strip()[:160]
|
||
or "建议先评估是否复用或合并。",
|
||
}
|
||
)
|
||
elif isinstance(row, str) and row.strip():
|
||
normalized.append(
|
||
{
|
||
"project_id": None,
|
||
"title": row.strip()[:120],
|
||
"difference": "模型未提供详细差异，建议人工确认。",
|
||
"risk": "存在重复建设的可能。",
|
||
"reuse_suggestion": "建议先核对项目是否同名或高度相似。",
|
||
}
|
||
)
|
||
if normalized:
|
||
return normalized[:3]
|
||
|
||
if fallback_candidates:
|
||
return [
|
||
{
|
||
"project_id": int(row.get("project_id")),
|
||
"title": str(row.get("title") or "").strip()[:120],
|
||
"difference": str(row.get("difference") or "").strip()[:160] or "需确认范围差异。",
|
||
"risk": str(row.get("risk") or "").strip()[:160] or "可能存在重复建设风险。",
|
||
"reuse_suggestion": str(row.get("reuse_suggestion") or "").strip()[:160] or "建议先评估是否复用或合并。",
|
||
}
|
||
for row in fallback_candidates[:3]
|
||
if DraftGeneratorService._safe_int(row.get("project_id")) is not None
|
||
]
|
||
|
||
query = " ".join(part for part in [title, original_text] if str(part or "").strip())
|
||
for row in active_projects[:3]:
|
||
project_title = str(row.get("title") or row.get("name") or "").strip()
|
||
if not project_title:
|
||
continue
|
||
if query and (project_title in query or query in project_title):
|
||
normalized.append(
|
||
{
|
||
"project_id": int(row.get("project_id") or 0),
|
||
"title": project_title,
|
||
"difference": "名称高度接近，建议确认是否为同一项目范围。",
|
||
"risk": "若直接新建，容易造成重复建设。",
|
||
"reuse_suggestion": "建议复用现有项目或先合并范围。",
|
||
}
|
||
)
|
||
return normalized[:3]
|
||
|
||
@staticmethod
|
||
def _normalize_string_list(
|
||
value: Any,
|
||
*,
|
||
fallback: list[str],
|
||
max_items: int,
|
||
max_length: int,
|
||
) -> list[str]:
|
||
items: list[str] = []
|
||
if isinstance(value, list):
|
||
for row in value:
|
||
if isinstance(row, str):
|
||
text = " ".join(row.split()).strip()[:max_length]
|
||
elif isinstance(row, dict):
|
||
text = " ".join(
|
||
str(row.get(key) or "").strip()
|
||
for key in ("text", "title", "content", "summary", "name")
|
||
if str(row.get(key) or "").strip()
|
||
).strip()[:max_length]
|
||
if not text:
|
||
text = " ".join(str(row.get("value") or "").split()).strip()[:max_length]
|
||
else:
|
||
text = ""
|
||
if text:
|
||
items.append(text)
|
||
if len(items) >= max_items:
|
||
break
|
||
if items:
|
||
return items[:max_items]
|
||
return [str(item).strip()[:max_length] for item in fallback if str(item).strip()][:max_items]
|
||
|
||
@staticmethod
|
||
def _render_bullet_items(
|
||
items: list[Any],
|
||
*,
|
||
default_line: str,
|
||
formatter: Any,
|
||
max_items: int,
|
||
) -> list[str]:
|
||
lines: list[str] = []
|
||
if isinstance(items, list):
|
||
for item in items[:max_items]:
|
||
line = formatter(item)
|
||
if line:
|
||
lines.append(line)
|
||
if not lines:
|
||
lines = [default_line]
|
||
return lines
|
||
|
||
@staticmethod
|
||
def _render_text_item_line(item: Any) -> str:
|
||
if isinstance(item, str):
|
||
text = " ".join(item.split()).strip()
|
||
elif isinstance(item, dict):
|
||
text = " ".join(
|
||
str(item.get(key) or "").strip()
|
||
for key in ("text", "title", "content", "summary", "name")
|
||
if str(item.get(key) or "").strip()
|
||
).strip()
|
||
if not text:
|
||
text = " ".join(str(item.get("value") or "").split()).strip()
|
||
else:
|
||
text = ""
|
||
if not text:
|
||
return ""
|
||
return f"· {text[:120]}"
|
||
|
||
@staticmethod
|
||
def _render_similar_project_line(item: Any) -> str:
|
||
if not isinstance(item, dict):
|
||
return DraftGeneratorService._render_text_item_line(item)
|
||
project_id = DraftGeneratorService._safe_int(item.get("project_id"))
|
||
title = str(item.get("title") or "").strip()[:60]
|
||
difference = str(item.get("difference") or "").strip()[:120]
|
||
risk = str(item.get("risk") or "").strip()[:80]
|
||
reuse = str(item.get("reuse_suggestion") or "").strip()[:100]
|
||
parts = []
|
||
if project_id is not None:
|
||
parts.append(f"#{project_id}")
|
||
if title:
|
||
parts.append(title)
|
||
prefix = " ".join(parts) or "相似项目"
|
||
detail_parts = [part for part in [difference, risk, reuse] if part]
|
||
detail = "；".join(detail_parts) if detail_parts else "建议先确认范围边界。"
|
||
return f"· {prefix}：{detail}"
|
||
|
||
@staticmethod
|
||
def _split_paragraph_lines(text: str) -> list[str]:
|
||
normalized = " ".join(str(text or "").split()).strip()
|
||
if not normalized:
|
||
return ["· 暂无"]
|
||
return [f"· {chunk.strip()}" for chunk in re.split(r"[。；;]\s*", normalized) if chunk.strip()][:3]
|
||
|
||
@staticmethod
|
||
def _safe_int(value: Any) -> Optional[int]:
|
||
try:
|
||
if value is None or value == "":
|
||
return None
|
||
return int(value)
|
||
except Exception:
|
||
return None
|
||
|
||
@staticmethod
|
||
def _safe_float(value: Any) -> float:
|
||
try:
|
||
return float(value or 0.0)
|
||
except Exception:
|
||
return 0.0
|