Repository navigation
Expand file tree
/
Copy pathcode_implementation_agent.py
More file actions
1093 lines (937 loc) · 44.4 KB
/
Copy pathcode_implementation_agent.py
File metadata and controls
1093 lines (937 loc) · 44.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
"""
Code Implementation Agent for File-by-File Development
文件逐个开发的代码实现代理
Handles systematic code implementation with progress tracking and
memory optimization for long-running development sessions.
处理系统性代码实现,具有进度跟踪和长时间开发会话的内存优化。
"""
import json
import time
import logging
from typing import Dict, Any, List, Optional
# Import tiktoken for token calculation
try:
import tiktoken
TIKTOKEN_AVAILABLE = True
except ImportError:
TIKTOKEN_AVAILABLE = False
# Import prompts from code_prompts
import sys
import os
sys.path.insert(
0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
)
from prompts.code_prompts import (
GENERAL_CODE_IMPLEMENTATION_SYSTEM_PROMPT,
)
class CodeImplementationAgent:
"""
Code Implementation Agent for systematic file-by-file development
用于系统性文件逐个开发的代码实现代理
Responsibilities / 职责:
- Track file implementation progress / 跟踪文件实现进度
- Execute MCP tool calls for code generation / 执行MCP工具调用进行代码生成
- Monitor implementation status / 监控实现状态
- Coordinate with Summary Agent for memory optimization / 与总结代理协调进行内存优化
- Calculate token usage for context management / 计算token使用量用于上下文管理
"""
def __init__(
self,
mcp_agent,
logger: Optional[logging.Logger] = None,
enable_read_tools: bool = True,
):
"""
Initialize Code Implementation Agent
初始化代码实现代理
Args:
mcp_agent: MCP agent instance for tool calls
logger: Logger instance for tracking operations
enable_read_tools: Whether to enable read_file and read_code_mem tools (default: True)
"""
self.mcp_agent = mcp_agent
self.logger = logger or self._create_default_logger()
self.enable_read_tools = enable_read_tools # Control read tools execution
self.implementation_summary = {
"completed_files": [],
"technical_decisions": [],
"important_constraints": [],
"architecture_notes": [],
"dependency_analysis": [], # Track dependency analysis and file reads
}
self.files_implemented_count = 0
self.implemented_files_set = set() # Track unique file paths to avoid duplicate counting / 跟踪唯一文件路径以避免重复计数
self.files_read_for_dependencies = (
set()
) # Track files read for dependency analysis / 跟踪为依赖分析而读取的文件
self.last_summary_file_count = 0 # Track the file count when last summary was triggered / 跟踪上次触发总结时的文件数
# Token calculation settings / Token计算设置
self.max_context_tokens = 200000 # Default max context tokens for Claude-3.5-Sonnet / Claude-3.5-Sonnet的默认最大上下文tokens
self.token_buffer = (
10000 # Safety buffer before reaching max / 达到最大值前的安全缓冲区
)
self.summary_trigger_tokens = (
self.max_context_tokens - self.token_buffer
) # Trigger summary when approaching limit / 接近限制时触发总结
self.last_summary_token_count = 0 # Track token count when last summary was triggered / 跟踪上次触发总结时的token数
# Initialize tokenizer / 初始化tokenizer
if TIKTOKEN_AVAILABLE:
try:
# Use Claude-3 tokenizer (approximation with OpenAI's o200k_base) / 使用Claude-3 tokenizer(用OpenAI的o200k_base近似)
self.tokenizer = tiktoken.get_encoding("o200k_base")
self.logger.info("Token calculation enabled with o200k_base encoding")
except Exception as e:
self.tokenizer = None
self.logger.warning(f"Failed to initialize tokenizer: {e}")
else:
self.tokenizer = None
self.logger.warning(
"tiktoken not available, token-based summary triggering disabled"
)
# Analysis loop detection / 分析循环检测
self.recent_tool_calls = [] # Track recent tool calls to detect analysis loops / 跟踪最近的工具调用以检测分析循环
self.max_read_without_write = 5 # Max read_file calls without write_file / 没有write_file的最大read_file调用次数
# Memory agent integration / 内存代理集成
self.memory_agent = None # Will be set externally / 将从外部设置
self.llm_client = None # Will be set externally / 将从外部设置
self.llm_client_type = None # Will be set externally / 将从外部设置
# Log read tools configuration
read_tools_status = "ENABLED" if self.enable_read_tools else "DISABLED"
self.logger.info(
f"🔧 Code Implementation Agent initialized - Read tools: {read_tools_status}"
)
if not self.enable_read_tools:
self.logger.info(
"🚫 Testing mode: read_file and read_code_mem will be skipped when called"
)
def _create_default_logger(self) -> logging.Logger:
"""Create default logger if none provided / 如果未提供则创建默认日志记录器"""
logger = logging.getLogger(f"{__name__}.CodeImplementationAgent")
# Don't add handlers to child loggers - let them propagate to root
logger.setLevel(logging.INFO)
return logger
def get_system_prompt(self) -> str:
"""
Get the system prompt for code implementation
获取代码实现的系统提示词
"""
return GENERAL_CODE_IMPLEMENTATION_SYSTEM_PROMPT
def set_memory_agent(self, memory_agent, llm_client=None, llm_client_type=None):
"""
Set memory agent for code summary generation
设置内存代理用于代码总结生成
Args:
memory_agent: Memory agent instance
llm_client: LLM client for summary generation
llm_client_type: Type of LLM client ("anthropic" or "openai")
"""
self.memory_agent = memory_agent
self.llm_client = llm_client
self.llm_client_type = llm_client_type
self.logger.info("Memory agent integration configured")
async def execute_tool_calls(self, tool_calls: List[Dict]) -> List[Dict]:
"""
Execute MCP tool calls and track implementation progress
执行MCP工具调用并跟踪实现进度
Args:
tool_calls: List of tool calls to execute
Returns:
List of tool execution results
"""
results = []
for tool_call in tool_calls:
tool_name = tool_call["name"]
tool_input = tool_call["input"]
self.logger.info(f"Executing MCP tool: {tool_name}")
try:
# Check if read tools are disabled
if not self.enable_read_tools and tool_name in [
"read_file",
"read_code_mem",
]:
# self.logger.info(f"🚫 SKIPPING {tool_name} - Read tools disabled for testing")
# Return a mock result indicating the tool was skipped
mock_result = json.dumps(
{
"status": "skipped",
"message": f"{tool_name} tool disabled for testing",
"tool_disabled": True,
"original_input": tool_input,
},
ensure_ascii=False,
)
results.append(
{
"tool_id": tool_call["id"],
"tool_name": tool_name,
"result": mock_result,
}
)
continue
# read_code_mem is now a proper MCP tool, no special handling needed
# INTERCEPT read_file calls - redirect to read_code_mem first if memory agent is available
if tool_name == "read_file":
file_path = tool_call["input"].get("file_path", "unknown")
self.logger.info(f"🔍 READ_FILE CALL DETECTED: {file_path}")
self.logger.info(
f"📊 Files implemented count: {self.files_implemented_count}"
)
self.logger.info(
f"🧠 Memory agent available: {self.memory_agent is not None}"
)
# Enable optimization if memory agent is available (more aggressive approach)
if self.memory_agent is not None:
self.logger.info(
f"🔄 INTERCEPTING read_file call for {file_path} (memory agent available)"
)
result = await self._handle_read_file_with_memory_optimization(
tool_call
)
results.append(result)
continue
else:
self.logger.info(
"📁 NO INTERCEPTION: no memory agent available"
)
if self.mcp_agent:
# Execute tool call through MCP protocol / 通过MCP协议执行工具调用
result = await self.mcp_agent.call_tool(tool_name, tool_input)
# Track file implementation progress / 跟踪文件实现进度
if tool_name == "write_file":
await self._track_file_implementation_with_summary(
tool_call, result
)
elif tool_name == "read_file":
self._track_dependency_analysis(tool_call, result)
# Track tool calls for analysis loop detection / 跟踪工具调用以检测分析循环
self._track_tool_call_for_loop_detection(tool_name)
results.append(
{
"tool_id": tool_call["id"],
"tool_name": tool_name,
"result": result,
}
)
else:
results.append(
{
"tool_id": tool_call["id"],
"tool_name": tool_name,
"result": json.dumps(
{
"status": "error",
"message": "MCP agent not initialized",
},
ensure_ascii=False,
),
}
)
except Exception as e:
self.logger.error(f"MCP tool execution failed: {e}")
results.append(
{
"tool_id": tool_call["id"],
"tool_name": tool_name,
"result": json.dumps(
{"status": "error", "message": str(e)}, ensure_ascii=False
),
}
)
return results
# _handle_read_code_mem method removed - read_code_mem is now a proper MCP tool
async def _handle_read_file_with_memory_optimization(self, tool_call: Dict) -> Dict:
"""
Intercept read_file calls and redirect to read_code_mem if a summary exists.
This prevents unnecessary file reads if the summary is already available.
拦截read_file调用,如果存在摘要则重定向到read_code_mem。
这可以防止在摘要已经存在时进行不必要的文件读取。
"""
file_path = tool_call["input"].get("file_path")
if not file_path:
return {
"tool_id": tool_call["id"],
"tool_name": "read_file",
"result": json.dumps(
{"status": "error", "message": "file_path parameter is required"},
ensure_ascii=False,
),
}
# Check if a summary exists for this file using read_code_mem MCP tool
should_use_summary = False
if self.memory_agent and self.mcp_agent:
try:
# Use read_code_mem MCP tool to check if summary exists
read_code_mem_result = await self.mcp_agent.call_tool(
"read_code_mem", {"file_path": file_path}
)
# Parse the result to check if summary was found
import json
if isinstance(read_code_mem_result, str):
try:
result_data = json.loads(read_code_mem_result)
should_use_summary = (
result_data.get("status") == "summary_found"
)
except json.JSONDecodeError:
should_use_summary = False
except Exception as e:
self.logger.debug(f"read_code_mem check failed for {file_path}: {e}")
should_use_summary = False
if should_use_summary:
self.logger.info(f"🔄 READ_FILE INTERCEPTED: Using summary for {file_path}")
# Use the MCP agent to call read_code_mem tool
if self.mcp_agent:
result = await self.mcp_agent.call_tool(
"read_code_mem", {"file_path": file_path}
)
# Modify the result to indicate it was originally a read_file call
import json
try:
result_data = (
json.loads(result) if isinstance(result, str) else result
)
if isinstance(result_data, dict):
result_data["original_tool"] = "read_file"
result_data["optimization"] = "redirected_to_read_code_mem"
final_result = json.dumps(result_data, ensure_ascii=False)
else:
final_result = result
except (json.JSONDecodeError, TypeError):
final_result = result
return {
"tool_id": tool_call["id"],
"tool_name": "read_file", # Keep original tool name for tracking
"result": final_result,
}
else:
self.logger.warning(
"MCP agent not available for read_code_mem optimization"
)
else:
self.logger.info(
f"📁 READ_FILE: No summary for {file_path}, using actual file"
)
# Execute the original read_file call
if self.mcp_agent:
result = await self.mcp_agent.call_tool("read_file", tool_call["input"])
# Track dependency analysis for the actual file read
self._track_dependency_analysis(tool_call, result)
# Track tool calls for analysis loop detection
self._track_tool_call_for_loop_detection("read_file")
return {
"tool_id": tool_call["id"],
"tool_name": "read_file",
"result": result,
}
else:
return {
"tool_id": tool_call["id"],
"tool_name": "read_file",
"result": json.dumps(
{"status": "error", "message": "MCP agent not initialized"},
ensure_ascii=False,
),
}
async def _track_file_implementation_with_summary(
self, tool_call: Dict, result: Any
):
"""
Track file implementation and create code summary
跟踪文件实现并创建代码总结
Args:
tool_call: The write_file tool call
result: Result of the tool execution
"""
# First do the regular tracking
self._track_file_implementation(tool_call, result)
# Then create and save code summary if memory agent is available
if self.memory_agent and self.llm_client and self.llm_client_type:
try:
file_path = tool_call["input"].get("file_path")
file_content = tool_call["input"].get("content", "")
if file_path and file_content:
# Create code implementation summary
summary = await self.memory_agent.create_code_implementation_summary(
self.llm_client,
self.llm_client_type,
file_path,
file_content,
self.get_files_implemented_count(), # Pass the current file count
)
self.logger.info(
f"Created code summary for implemented file: {file_path}, summary: {summary[:100]}..."
)
else:
self.logger.warning(
"Missing file path or content for summary generation"
)
except Exception as e:
self.logger.error(f"Failed to create code summary: {e}")
def _track_file_implementation(self, tool_call: Dict, result: Any):
"""
Track file implementation progress
跟踪文件实现进度
"""
try:
# Handle different result types from MCP / 处理MCP的不同结果类型
result_data = None
# Check if result is a CallToolResult object / 检查结果是否为CallToolResult对象
if hasattr(result, "content"):
# Extract content from CallToolResult / 从CallToolResult提取内容
if hasattr(result.content, "text"):
result_content = result.content.text
else:
result_content = str(result.content)
# Try to parse as JSON / 尝试解析为JSON
try:
result_data = json.loads(result_content)
except json.JSONDecodeError:
# If not JSON, create a structure / 如果不是JSON,创建一个结构
result_data = {
"status": "success",
"file_path": tool_call["input"].get("file_path", "unknown"),
}
elif isinstance(result, str):
# Try to parse string result / 尝试解析字符串结果
try:
result_data = json.loads(result)
except json.JSONDecodeError:
result_data = {
"status": "success",
"file_path": tool_call["input"].get("file_path", "unknown"),
}
elif isinstance(result, dict):
# Direct dictionary result / 直接字典结果
result_data = result
else:
# Fallback: assume success and extract file path from input / 后备方案:假设成功并从输入中提取文件路径
result_data = {
"status": "success",
"file_path": tool_call["input"].get("file_path", "unknown"),
}
# Extract file path for tracking / 提取文件路径用于跟踪
file_path = None
if result_data and result_data.get("status") == "success":
file_path = result_data.get(
"file_path", tool_call["input"].get("file_path", "unknown")
)
else:
file_path = tool_call["input"].get("file_path")
# Only count unique files, not repeated tool calls on same file / 只计数唯一文件,不重复计数同一文件的工具调用
if file_path and file_path not in self.implemented_files_set:
# This is a new file implementation / 这是一个新的文件实现
self.implemented_files_set.add(file_path)
self.files_implemented_count += 1
# self.logger.info(f"New file implementation tracked: count={self.files_implemented_count}, file={file_path}")
# print(f"New file implementation tracked: count={self.files_implemented_count}, file={file_path}")
# Add to completed files list / 添加到已完成文件列表
self.implementation_summary["completed_files"].append(
{
"file": file_path,
"iteration": self.files_implemented_count,
"timestamp": time.time(),
"size": result_data.get("size", 0) if result_data else 0,
}
)
# self.logger.info(
# f"New file implementation tracked: count={self.files_implemented_count}, file={file_path}"
# )
# print(f"📝 NEW FILE IMPLEMENTED: count={self.files_implemented_count}, file={file_path}")
# print(f"🔧 OPTIMIZATION NOW ENABLED: files_implemented_count > 0 = {self.files_implemented_count > 0}")
elif file_path and file_path in self.implemented_files_set:
# This file was already implemented (duplicate tool call) / 这个文件已经被实现过了(重复工具调用)
self.logger.debug(
f"File already tracked, skipping duplicate count: {file_path}"
)
else:
# No valid file path found / 没有找到有效的文件路径
self.logger.warning("No valid file path found for tracking")
except Exception as e:
self.logger.warning(f"Failed to track file implementation: {e}")
# Even if tracking fails, try to count based on tool input (but check for duplicates) / 即使跟踪失败,也尝试根据工具输入计数(但检查重复)
file_path = tool_call["input"].get("file_path")
if file_path and file_path not in self.implemented_files_set:
self.implemented_files_set.add(file_path)
self.files_implemented_count += 1
self.logger.info(
f"File implementation counted (emergency fallback): count={self.files_implemented_count}, file={file_path}"
)
def _track_dependency_analysis(self, tool_call: Dict, result: Any):
"""
Track dependency analysis through read_file calls
跟踪通过read_file调用进行的依赖分析
"""
try:
file_path = tool_call["input"].get("file_path")
if file_path:
# Track unique files read for dependency analysis / 跟踪为依赖分析而读取的唯一文件
if file_path not in self.files_read_for_dependencies:
self.files_read_for_dependencies.add(file_path)
# Add to dependency analysis summary / 添加到依赖分析总结
self.implementation_summary["dependency_analysis"].append(
{
"file_read": file_path,
"timestamp": time.time(),
"purpose": "dependency_analysis",
}
)
self.logger.info(
f"Dependency analysis tracked: file_read={file_path}"
)
except Exception as e:
self.logger.warning(f"Failed to track dependency analysis: {e}")
def calculate_messages_token_count(self, messages: List[Dict]) -> int:
"""
Calculate total token count for a list of messages
计算消息列表的总token数
Args:
messages: List of chat messages with 'role' and 'content' keys
Returns:
Total token count
"""
if not self.tokenizer:
# Fallback: rough estimation based on character count / 回退:基于字符数的粗略估计
total_chars = sum(len(str(msg.get("content", ""))) for msg in messages)
# Rough approximation: 1 token ≈ 4 characters / 粗略近似:1个token ≈ 4个字符
return total_chars // 4
try:
total_tokens = 0
for message in messages:
content = str(message.get("content", ""))
role = message.get("role", "")
# Count tokens for content / 计算内容的token数
if content:
content_tokens = len(
self.tokenizer.encode(content, disallowed_special=())
)
total_tokens += content_tokens
# Add tokens for role and message structure / 为角色和消息结构添加token
role_tokens = len(self.tokenizer.encode(role, disallowed_special=()))
total_tokens += (
role_tokens + 4
) # Extra tokens for message formatting / 消息格式化的额外token
return total_tokens
except Exception as e:
self.logger.warning(f"Token calculation failed: {e}")
# Fallback estimation / 回退估计
total_chars = sum(len(str(msg.get("content", ""))) for msg in messages)
return total_chars // 4
def should_trigger_summary_by_tokens(self, messages: List[Dict]) -> bool:
"""
Check if summary should be triggered based on token count
根据token数检查是否应触发总结
Args:
messages: Current conversation messages
Returns:
True if summary should be triggered based on token count
"""
if not messages:
return False
# Calculate current token count / 计算当前token数
current_token_count = self.calculate_messages_token_count(messages)
# Check if we should trigger summary / 检查是否应触发总结
should_trigger = (
current_token_count > self.summary_trigger_tokens
and current_token_count
> self.last_summary_token_count
+ 10000 # Minimum 10k tokens between summaries / 总结间最少10k tokens
)
if should_trigger:
self.logger.info(
f"Token-based summary trigger: current={current_token_count:,}, "
f"threshold={self.summary_trigger_tokens:,}, "
f"last_summary={self.last_summary_token_count:,}"
)
return should_trigger
def should_trigger_summary(
self, summary_trigger: int = 5, messages: List[Dict] = None
) -> bool:
"""
Check if summary should be triggered based on token count (preferred) or file count (fallback)
根据token数(首选)或文件数(回退)检查是否应触发总结
Args:
summary_trigger: Number of files after which to trigger summary (fallback)
messages: Current conversation messages for token calculation
Returns:
True if summary should be triggered
"""
# Primary: Token-based triggering / 主要:基于token的触发
if messages and self.tokenizer:
return self.should_trigger_summary_by_tokens(messages)
# Fallback: File-based triggering (original logic) / 回退:基于文件的触发(原始逻辑)
self.logger.info("Using fallback file-based summary triggering")
should_trigger = (
self.files_implemented_count > 0
and self.files_implemented_count % summary_trigger == 0
and self.files_implemented_count > self.last_summary_file_count
)
return should_trigger
def mark_summary_triggered(self, messages: List[Dict] = None):
"""
Mark that summary has been triggered for current state
标记当前状态的总结已被触发
Args:
messages: Current conversation messages for token tracking
"""
# Update file-based tracking / 更新基于文件的跟踪
self.last_summary_file_count = self.files_implemented_count
# Update token-based tracking / 更新基于token的跟踪
if messages and self.tokenizer:
self.last_summary_token_count = self.calculate_messages_token_count(
messages
)
self.logger.info(
f"Summary marked as triggered - file_count: {self.files_implemented_count}, "
f"token_count: {self.last_summary_token_count:,}"
)
else:
self.logger.info(
f"Summary marked as triggered for file count: {self.files_implemented_count}"
)
def get_implementation_summary(self) -> Dict[str, Any]:
"""
Get current implementation summary
获取当前实现总结
"""
return self.implementation_summary.copy()
def get_files_implemented_count(self) -> int:
"""
Get the number of files implemented so far
获取到目前为止实现的文件数量
"""
return self.files_implemented_count
def get_read_tools_status(self) -> Dict[str, Any]:
"""
Get read tools configuration status
获取读取工具配置状态
Returns:
Dictionary with read tools status information
"""
return {
"read_tools_enabled": self.enable_read_tools,
"status": "ENABLED" if self.enable_read_tools else "DISABLED",
"tools_affected": ["read_file", "read_code_mem"],
"description": "Read tools configuration for testing purposes",
}
def add_technical_decision(self, decision: str, context: str = ""):
"""
Add a technical decision to the implementation summary
向实现总结添加技术决策
Args:
decision: Description of the technical decision
context: Additional context for the decision
"""
self.implementation_summary["technical_decisions"].append(
{"decision": decision, "context": context, "timestamp": time.time()}
)
self.logger.info(f"Technical decision recorded: {decision}")
def add_constraint(self, constraint: str, impact: str = ""):
"""
Add an important constraint to the implementation summary
向实现总结添加重要约束
Args:
constraint: Description of the constraint
impact: Impact of the constraint on implementation
"""
self.implementation_summary["important_constraints"].append(
{"constraint": constraint, "impact": impact, "timestamp": time.time()}
)
self.logger.info(f"Constraint recorded: {constraint}")
def add_architecture_note(self, note: str, component: str = ""):
"""
Add an architecture note to the implementation summary
向实现总结添加架构注释
Args:
note: Architecture note description
component: Related component or module
"""
self.implementation_summary["architecture_notes"].append(
{"note": note, "component": component, "timestamp": time.time()}
)
self.logger.info(f"Architecture note recorded: {note}")
def get_implementation_statistics(self) -> Dict[str, Any]:
"""
Get comprehensive implementation statistics
获取全面的实现统计信息
"""
return {
"total_files_implemented": self.files_implemented_count,
"files_implemented_count": self.files_implemented_count,
"technical_decisions_count": len(
self.implementation_summary["technical_decisions"]
),
"constraints_count": len(
self.implementation_summary["important_constraints"]
),
"architecture_notes_count": len(
self.implementation_summary["architecture_notes"]
),
"dependency_analysis_count": len(
self.implementation_summary["dependency_analysis"]
),
"files_read_for_dependencies": len(self.files_read_for_dependencies),
"unique_files_implemented": len(self.implemented_files_set),
"completed_files_list": [
f["file"] for f in self.implementation_summary["completed_files"]
],
"dependency_files_read": list(self.files_read_for_dependencies),
"last_summary_file_count": self.last_summary_file_count,
"read_tools_status": self.get_read_tools_status(), # Include read tools configuration
}
def force_enable_optimization(self):
"""
Force enable optimization for testing purposes
强制启用优化用于测试目的
"""
self.files_implemented_count = 1
self.logger.info(
f"🔧 OPTIMIZATION FORCE ENABLED: files_implemented_count set to {self.files_implemented_count}"
)
print(
f"🔧 OPTIMIZATION FORCE ENABLED: files_implemented_count set to {self.files_implemented_count}"
)
def reset_implementation_tracking(self):
"""
Reset implementation tracking (useful for new sessions)
重置实现跟踪(对新会话有用)
"""
self.implementation_summary = {
"completed_files": [],
"technical_decisions": [],
"important_constraints": [],
"architecture_notes": [],
"dependency_analysis": [], # Reset dependency analysis and file reads
}
self.files_implemented_count = 0
self.implemented_files_set = (
set()
) # Reset the unique files set / 重置唯一文件集合
self.files_read_for_dependencies = (
set()
) # Reset files read for dependency analysis / 重置为依赖分析而读取的文件
self.last_summary_file_count = 0 # Reset the file count when last summary was triggered / 重置上次触发总结时的文件数
self.last_summary_token_count = 0 # Reset token count when last summary was triggered / 重置上次触发总结时的token数
self.logger.info("Implementation tracking reset")
# Reset analysis loop detection / 重置分析循环检测
self.recent_tool_calls = []
self.logger.info("Analysis loop detection reset")
def _track_tool_call_for_loop_detection(self, tool_name: str):
"""
Track tool calls for analysis loop detection
跟踪工具调用以检测分析循环
Args:
tool_name: Name of the tool called
"""
self.recent_tool_calls.append(tool_name)
if len(self.recent_tool_calls) > self.max_read_without_write:
self.recent_tool_calls.pop(0)
if len(set(self.recent_tool_calls)) == 1:
self.logger.warning("Analysis loop detected")
def is_in_analysis_loop(self) -> bool:
"""
Check if the agent is in an analysis loop (only reading files, not writing)
检查代理是否在分析循环中(只读文件,不写文件)
Returns:
True if in analysis loop
"""
if len(self.recent_tool_calls) < self.max_read_without_write:
return False
# Check if recent calls are all read_file or search_reference_code / 检查最近的调用是否都是read_file或search_reference_code
analysis_tools = {
"read_file",
"search_reference_code",
"get_all_available_references",
}
recent_calls_set = set(self.recent_tool_calls)
# If all recent calls are analysis tools, we're in an analysis loop / 如果最近的调用都是分析工具,我们在分析循环中
in_loop = (
recent_calls_set.issubset(analysis_tools) and len(recent_calls_set) >= 1
)
if in_loop:
self.logger.warning(
f"Analysis loop detected! Recent calls: {self.recent_tool_calls}"
)
return in_loop
def get_analysis_loop_guidance(self) -> str:
"""
Get guidance to break out of analysis loop
获取跳出分析循环的指导
Returns:
Guidance message to encourage implementation
"""
return f"""🚨 **ANALYSIS LOOP DETECTED - IMMEDIATE ACTION REQUIRED**
**Problem**: You've been reading/analyzing files for {len(self.recent_tool_calls)} consecutive calls without writing code.
**Recent tool calls**: {' → '.join(self.recent_tool_calls)}
**SOLUTION - IMPLEMENT CODE NOW**:
1. **STOP ANALYZING** - You have enough information
2. **Use write_file** to create the next code file according to the implementation plan
3. **Choose ANY file** from the plan that hasn't been implemented yet
4. **Write complete, working code** - don't ask for permission or clarification
**Files implemented so far**: {self.files_implemented_count}
**Your goal**: Implement MORE files, not analyze existing ones!
**CRITICAL**: Your next response MUST use write_file to create a new code file!"""
async def test_summary_functionality(self, test_file_path: str = None):
"""
Test if the code summary functionality is working correctly
测试代码总结功能是否正常工作
Args:
test_file_path: Specific file to test, if None will test all implemented files
"""
if not self.memory_agent:
self.logger.warning("No memory agent available for testing")
return
if test_file_path:
files_to_test = [test_file_path]
else:
# Use implemented files from tracking
files_to_test = list(self.implemented_files_set)[
:3
] # Limit to first 3 files
if not files_to_test:
self.logger.warning("No implemented files to test")
return
# Test each file silently
summary_files_found = 0
for file_path in files_to_test:
if self.mcp_agent:
try:
result = await self.mcp_agent.call_tool(
"read_code_mem", {"file_path": file_path}
)
# Parse the result to check if summary was found
import json
result_data = (
json.loads(result) if isinstance(result, str) else result
)
if result_data.get("status") == "summary_found":
summary_files_found += 1
except Exception as e:
self.logger.warning(
f"Failed to test read_code_mem for {file_path}: {e}"
)
else:
self.logger.warning("MCP agent not available for testing")
self.logger.info(
f"📋 Summary testing: {summary_files_found}/{len(files_to_test)} files have summaries"
)
async def test_automatic_read_file_optimization(self):
"""
Test the automatic read_file optimization that redirects to read_code_mem
测试自动read_file优化,重定向到read_code_mem
"""
print("=" * 80)
print("🔄 TESTING AUTOMATIC READ_FILE OPTIMIZATION")
print("=" * 80)
# Simulate that at least one file has been implemented (to trigger optimization)
self.files_implemented_count = 1
# Test with a file that should have a summary
test_file = "rice/config.py"
print(f"📁 Testing automatic optimization for: {test_file}")
print(f"📊 Files implemented count: {self.files_implemented_count}")
print(
f"🔧 Optimization should be: {'ENABLED' if self.files_implemented_count > 0 else 'DISABLED'}"
)
# Create a simulated read_file tool call
simulated_read_file_call = {
"id": "test_read_file_optimization",
"name": "read_file",
"input": {"file_path": test_file},
}
print("\n🔄 Simulating read_file call:")
print(f" Tool: {simulated_read_file_call['name']}")
print(f" File: {simulated_read_file_call['input']['file_path']}")
# Execute the tool call (this should trigger automatic optimization)
results = await self.execute_tool_calls([simulated_read_file_call])
if results:
result = results[0]
print("\n✅ Tool execution completed:")
print(f" Tool name: {result.get('tool_name', 'N/A')}")
print(f" Tool ID: {result.get('tool_id', 'N/A')}")
# Parse the result to check if optimization occurred
import json
try:
result_data = json.loads(result.get("result", "{}"))
if result_data.get("optimization") == "redirected_to_read_code_mem":
print("🎉 SUCCESS: read_file was automatically optimized!")
print(
f" Original tool: {result_data.get('original_tool', 'N/A')}"
)