class CodeIngestion:
    def ingest_from_github(self, repo_url):
        # 拉取代码
        code = self.git_client.clone(repo_url)
        
        # 拉取历史
        commits = self.git_client.get_commit_history()
        
        # 拉取PR和Issue
        prs = self.github_api.get_pull_requests()
        issues = self.github_api.get_issues()
        
        # 拉取文档
        docs = self.extract_documentation(code)
        
        return {
            'code': code,
            'history': commits,
            'prs': prs,
            'issues': issues,
            'docs': docs
        }

class CodeParser:
    def parse_code(self, source_files):
        ast_trees = {}
        symbol_tables = {}
        dependency_graph = nx.DiGraph()
        call_graph = nx.DiGraph()
        
        for file in source_files:
            # 解析AST
            ast_tree = self.parser.parse(file.content)
            ast_trees[file.path] = ast_tree
            
            # 提取符号
            symbols = self.extract_symbols(ast_tree)
            symbol_tables[file.path] = symbols
            
            # 构建依赖图
            imports = self.extract_imports(ast_tree)
            for imp in imports:
                dependency_graph.add_edge(file.path, imp)
            
            # 构建调用图
            calls = self.extract_function_calls(ast_tree)
            for call in calls:
                call_graph.add_edge(file.path, call)
        
        return {
            'ast': ast_trees,
            'symbols': symbol_tables,
            'dependencies': dependency_graph,
            'calls': call_graph
        }

class SemanticIndex:
    def __init__(self):
        self.encoder = CodeEncoder()  # 如CodeBERT, GraphCodeBERT
        self.vector_db = VectorDatabase()  # 如Pinecone, Weaviate
    
    def index_code(self, code_chunks):
        for chunk in code_chunks:
            # 生成embedding
            embedding = self.encoder.encode(chunk.content)
            
            # 存储到向量数据库
            self.vector_db.insert(
                id=chunk.id,
                vector=embedding,
                metadata={
                    'file': chunk.file_path,
                    'type': chunk.type,  # function, class, etc.
                    'content': chunk.content
                }
            )
    
    def semantic_search(self, query, top_k=10):
        # 将查询转为向量
        query_embedding = self.encoder.encode(query)
        
        # 向量相似度搜索
        results = self.vector_db.search(
            vector=query_embedding,
            top_k=top_k
        )
        
        return results

class KnowledgeGraphBuilder:
    def __init__(self):
        self.graph = nx.DiGraph()
    
    def build_from_code(self, parsed_code):
        # 识别服务
        services = self.identify_services(parsed_code)
        for service in services:
            self.graph.add_node(
                service.name,
                type='service',
                properties=service.properties
            )
        
        # 识别API
        apis = self.identify_apis(parsed_code)
        for api in apis:
            self.graph.add_node(
                api.endpoint,
                type='api',
                properties=api.properties
            )
            # API属于哪个服务
            self.graph.add_edge(
                api.service,
                api.endpoint,
                relation='exposes'
            )
        
        # 识别业务实体
        entities = self.identify_business_entities(parsed_code)
        for entity in entities:
            self.graph.add_node(
                entity.name,
                type='entity',
                properties=entity.properties
            )
        
        # 识别关系
        relations = self.identify_relations(parsed_code)
        for rel in relations:
            self.graph.add_edge(
                rel.source,
                rel.target,
                relation=rel.type,
                properties=rel.properties
            )
        
        return self.graph
    
    def query_knowledge(self, query):
        # Cypher-like查询
        # MATCH (s:Service)-[:calls]->(t:Service)
        # WHERE s.name = 'order-service'
        # RETURN t
        pass

class ReasoningEngine:
    def __init__(self, knowledge_graph, semantic_index):
        self.kg = knowledge_graph
        self.index = semantic_index
        self.llm = LargeLanguageModel()
    
    def answer_question(self, question):
        # 1. 理解问题意图
        intent = self.parse_intent(question)
        
        # 2. 检索相关信息
        if intent.type == 'code_location':
            # 语义搜索代码
            context = self.index.semantic_search(question)
        elif intent.type == 'system_reasoning':
            # 知识图谱查询
            context = self.query_knowledge_graph(intent)
        
        # 3. 使用LLM生成答案
        answer = self.llm.generate(
            prompt=self.build_prompt(question, context),
            context=context
        )
        
        # 4. 验证答案
        verified_answer = self.verify_answer(answer, context)
        
        return verified_answer
    
    def analyze_impact(self, code_change):
        # 分析代码变更的影响范围
        affected_services = self.traverse_kg(
            start=code_change.location,
            relation='calls',
            depth=3
        )
        
        affected_tests = self.identify_related_tests(
            code_change
        )
        
        risk_score = self.calculate_risk(
            affected_services,
            affected_tests
        )
        
        return {
            'services': affected_services,
            'tests': affected_tests,
            'risk': risk_score
        }

# 代码中的业务逻辑
if user.is_vip and order.amount > 1000:
    discount = 0.2  # VIP满1000打8折
elif today.is_black_friday:
    discount = 0.5  # 黑五5折