import logging from pathlib import Path from dataclasses import dataclass, field from agent.code_analyzer import FileAnalysis, ClassInfo, FunctionInfo logger = logging.getLogger(__name__) @dataclass class BoundedContext: name: str description: str aggregate_roots: list[str] = field(default_factory=list) entities: list[str] = field(default_factory=list) value_objects: list[str] = field(default_factory=list) domain_services: list[str] = field(default_factory=list) repositories: list[str] = field(default_factory=list) files: list[str] = field(default_factory=list) @dataclass class DomainModel: bounded_contexts: list[BoundedContext] = field(default_factory=list) shared_kernel: list[str] = field(default_factory=list) ubiquitous_language: dict[str, str] = field(default_factory=dict) class DomainExtractor: def __init__(self, repo_path: Path): self.repo_path = Path(repo_path) def extract_domains(self, analyses: list[FileAnalysis]) -> DomainModel: domain_model = DomainModel() module_groups = self._group_by_module(analyses) ubiquitous_language = self._extract_ubiquitous_language(analyses) for module_name, files in module_groups.items(): context = self._analyze_module(module_name, files) if context: domain_model.bounded_contexts.append(context) domain_model.shared_kernel = self._identify_shared_kernel(analyses) domain_model.ubiquitous_language = ubiquitous_language return domain_model def _group_by_module(self, analyses: list[FileAnalysis]) -> dict[str, list[FileAnalysis]]: groups = {} for analysis in analyses: parts = Path(analysis.path).parts if len(parts) > 1: top_level = parts[0] else: top_level = "root" if top_level not in ("tests", "test", "__pycache__", ".git"): if top_level not in groups: groups[top_level] = [] groups[top_level].append(analysis) return groups def _analyze_module(self, module_name: str, analyses: list[FileAnalysis]) -> BoundedContext: context = BoundedContext(name=module_name, description=f"{module_name} 限界上下文") for analysis in analyses: for cls in analysis.classes: class_name = cls.name.lower() file_path = cls.file_path if cls.base_classes: context.files.append(file_path) if any(kw in class_name for kw in ("repository", "repo", "dao")): context.repositories.append(cls.name) elif any(kw in class_name for kw in ("service", "manager", "handler", "usecase")): context.domain_services.append(cls.name) elif any(kw in class_name for kw in ("model", "entity", "aggregate", "root")): context.aggregate_roots.append(cls.name) elif any(kw in class_name for kw in ("dto", "vo", "value", "event", "command", "query", "request", "response")): context.value_objects.append(cls.name) elif any(kw in class_name for kw in ("config", "util", "helper", "constant", "enum", "type")): context.value_objects.append(cls.name) else: context.entities.append(cls.name) for func in analysis.functions: if func.name.startswith("_"): continue context.files.append(analysis.path) context.files = list(set(context.files)) return context def _extract_ubiquitous_language(self, analyses: list[FileAnalysis]) -> dict[str, str]: language = {} for analysis in analyses: for cls in analysis.classes: if cls.docstring: first_line = cls.docstring.split("\n")[0].strip() if first_line and len(first_line) < 200: language[cls.name] = first_line for func in analysis.functions: if func.docstring: first_line = func.docstring.split("\n")[0].strip() if first_line and len(first_line) < 200: language[func.name] = first_line return language def _identify_shared_kernel(self, analyses: list[FileAnalysis]) -> list[str]: shared = [] for analysis in analyses: for cls in analysis.classes: if any(kw in cls.name.lower() for kw in ( "base", "abstract", "interface", "protocol", "mixin" )): if cls.base_classes: shared.append(cls.name) return shared def map_file_to_context(self, file_path: str, contexts: list[BoundedContext]) -> str: parts = Path(file_path).parts if len(parts) > 1: top_level = parts[0] for ctx in contexts: if ctx.name == top_level: return ctx.name return "shared_kernel" def generate_context_report(self, domain_model: DomainModel) -> str: lines = ["# DDD 领域分析报告", ""] lines.append(f"## 限界上下文 ({len(domain_model.bounded_contexts)} 个)", "") for ctx in domain_model.bounded_contexts: lines.append(f"### {ctx.name}") lines.append(f"- 描述: {ctx.description}") lines.append(f"- 聚合根: {', '.join(ctx.aggregate_roots) if ctx.aggregate_roots else '无'}") lines.append(f"- 实体: {', '.join(ctx.entities) if ctx.entities else '无'}") lines.append(f"- 领域服务: {', '.join(ctx.domain_services) if ctx.domain_services else '无'}") lines.append(f"- 仓储: {', '.join(ctx.repositories) if ctx.repositories else '无'}") lines.append(f"- 值对象: {', '.join(ctx.value_objects) if ctx.value_objects else '无'}") lines.append(f"- 涉及文件: {len(ctx.files)} 个") lines.append("") if domain_model.shared_kernel: lines.append(f"## 共享内核: {', '.join(domain_model.shared_kernel)}", "") if domain_model.ubiquitous_language: lines.append("## 统一语言", "") for term, definition in list(domain_model.ubiquitous_language.items())[:20]: lines.append(f"- **{term}**: {definition}") return "\n".join(lines)