auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/ac_style_command_parser/test_parser.py

@@ -1,5 +1,6 @@
 
 import pytest
+from collections import OrderedDict
 from typing import Dict, List, Any
 
 # 导入被测模块
@@ -8,7 +9,8 @@ from .parser import (
     parse_query,
     has_command,
     get_command_args,
-    get_command_kwargs
+    get_command_kwargs,
+    get_query_command
 )
 
 
@@ -82,6 +84,28 @@ class TestCommandParser:
             }
         }
         assert result == expected
+
+    def test_single_command_new_params(self, parser):
+        """测试单个命令混合参数"""
+        result = parser.parse('/new "把 /Users/williamzhu/.auto-coder/async_agent/tasks/stdin_20250815101939_e9042b6c 中未commit变更合并回来"')
+        expected = {
+            "new": {
+                "args": ['把 /Users/williamzhu/.auto-coder/async_agent/tasks/stdin_20250815101939_e9042b6c 中未commit变更合并回来'],
+                "kwargs": {}
+            }
+        }
+        assert result == expected   
+
+    def test_single_command_async_params(self, parser):
+        """测试单个命令混合参数"""
+        result = parser.parse("/async \"/list @./src/agent.ts 中,while 循环里有loop call limit 限制,当前会发出一个 emitEvent 事件,同时也需要发出一个渲染事件(opts.render方法)\"")
+        expected = {
+            "async": {
+                "args": ['/list @./src/agent.ts 中,while 循环里有loop call limit 限制,当前会发出一个 emitEvent 事件,同时也需要发出一个渲染事件(opts.render方法)'],
+                "kwargs": {}
+            }
+        }
+        assert result == expected      
     
     def test_quoted_args_double_quotes(self, parser):
         """测试双引号参数"""
@@ -153,6 +177,24 @@ class TestCommandParser:
         }
         assert result == expected
     
+    def test_command_order_preservation(self, parser):
+        """测试命令顺序保持"""
+        result = parser.parse("/third /first /second arg1 /fourth key=value")
+        
+        # 验证返回的是OrderedDict
+        assert isinstance(result, OrderedDict)
+        
+        # 验证命令顺序
+        command_order = list(result.keys())
+        expected_order = ["third", "first", "second", "fourth"]
+        assert command_order == expected_order
+        
+        # 验证内容正确性
+        assert result["third"]["args"] == []
+        assert result["first"]["args"] == []
+        assert result["second"]["args"] == ["arg1"]
+        assert result["fourth"]["kwargs"] == {"key": "value"}
+    
     def test_path_not_recognized_as_command(self, parser):
         """测试路径不被识别为命令"""
         result = parser.parse("/add /path/to/file.txt /config model=gpt-4")
@@ -243,6 +285,46 @@ class TestCommandParser:
             }
         }
         assert result == expected
+    
+    def test_auto_new_complex_scenario(self, parser):
+        """测试复杂的自动化场景：/auto /new 运行使用交互式方式运行 auto-coder.chat 然后在里面运行 /rules /list"""
+        query = "/auto /new 运行使用交互式方式运行 auto-coder.chat 然后在里面运行 /rules /list"
+        result = parser.parse(query)
+        expected = {
+            "auto": {
+                "args": [],
+                "kwargs": {}
+            },
+            "new": {
+                "args": ["运行使用交互式方式运行", "auto-coder.chat", "然后在里面运行"],
+                "kwargs": {}
+            },
+            "rules": {
+                "args": [],
+                "kwargs": {}
+            },
+            "list": {
+                "args": [],
+                "kwargs": {}
+            }
+        }
+        assert result == expected
+
+    def test_auto_new_complex_scenario2(self, parser):
+        """测试复杂的自动化场景：/auto /new 运行使用交互式方式运行 auto-coder.chat 然后在里面运行 /rules /list"""
+        query = '/auto /new "运行使用交互式方式运行 auto-coder.chat 然后在里面运行 /rules /list"'
+        result = parser.parse(query)
+        expected = {
+            "auto": {
+                "args": [],
+                "kwargs": {}
+            },
+            "new": {
+                "args": ["运行使用交互式方式运行 auto-coder.chat 然后在里面运行 /rules /list"],
+                "kwargs": {}
+            }            
+        }
+        assert result == expected    
 
 
 class TestConvenienceFunctions:
@@ -251,6 +333,10 @@ class TestConvenienceFunctions:
     def test_parse_query_function(self):
         """测试parse_query函数"""
         result = parse_query("/add file1.txt mode=fast")
+        
+        # 验证返回的是OrderedDict
+        assert isinstance(result, OrderedDict)
+        
         expected = {
             "add": {
                 "args": ["file1.txt"],
@@ -426,9 +512,12 @@ class TestErrorHandling:
         """测试命令中的特殊字符"""
         parser = CommandParser()
         
-        # 命令名只能包含单词字符，所以这些不会被识别为命令
+        # 命令名可以包含单词字符和连字符，但不能包含点号
         result = parser.parse("/test-command /test.command")
-        assert result == {}
+        expected = OrderedDict({
+            'test-command': {'args': ['/test.command'], 'kwargs': {}}
+        })
+        assert result == expected
     
     def test_whitespace_handling(self):
         """测试空白字符处理"""
@@ -460,19 +549,6 @@ class TestErrorHandling:
         }
         assert result == expected
 
-    def test__command_with_path(self, parser):
-        """测试单个命令混合参数"""
-        result = parser.parse('/command "tdd/hello.md" name="威廉"')
-        expected = {
-            "command": {
-                "args": ["tdd/hello.md"],
-                "kwargs": {
-                    "name": "威廉"
-                }
-            }
-        }
-        assert result == expected    
-
 
 # 参数化测试用例
 @pytest.mark.parametrize("query,expected_commands", [
@@ -511,6 +587,155 @@ def test_get_kwargs_parametrized(query, command, expected_kwargs):
     assert get_command_kwargs(query, command) == expected_kwargs
 
 
+class TestQueryCommand:
+    """测试 QueryCommand 类和 get_query_command 函数"""
+    
+    def test_basic_query_command(self):
+        """测试基本的 QueryCommand 功能"""
+        query = "/model gpt-4 /temperature 0.7"
+        v = get_query_command(query)
+        
+        assert v.model == "gpt-4"
+        assert v.temperature == "0.7"
+        assert v.query == ""
+    
+    def test_query_command_with_sub_commands(self):
+        """测试带子命令的 QueryCommand"""
+        query = "/async /model gpt-4 /task-prefix mytask hello world"
+        v = get_query_command(query, sub_commands=["model", "task-prefix"])
+        
+        assert v.model == "gpt-4"
+        assert v.task_prefix == "mytask"
+        assert v.query == "hello world"
+    
+    def test_query_command_hyphen_to_underscore(self):
+        """测试连字符自动转换为下划线"""
+        query = "/task-prefix mytask /api-key secret123"
+        v = get_query_command(query)
+        
+        # 可以用下划线访问
+        assert v.task_prefix == "mytask"
+        assert v.api_key == "secret123"
+    
+    def test_query_command_multiple_args(self):
+        """测试多个参数的处理"""
+        query = "/async /model gpt-4 /task-prefix mytask arg1 arg2 arg3"
+        v = get_query_command(query, sub_commands=["model", "task-prefix"])
+        
+        assert v.model == "gpt-4"
+        assert v.task_prefix == "mytask"
+        assert v.query == "arg1 arg2 arg3"
+    
+    def test_query_command_no_special_handling(self):
+        """测试不进行特殊处理的情况"""
+        query = "/model gpt-4 extra /task-prefix mytask arg1 arg2"
+        v = get_query_command(query, sub_commands=None)
+        
+        # 没有指定sub_commands，所以不会特殊处理
+        assert v.model == ["gpt-4", "extra"]
+        assert v.task_prefix == ["mytask", "arg1", "arg2"]
+        assert v.query == ""
+    
+    def test_query_command_with_kwargs(self):
+        """测试带键值对参数的命令"""
+        query = "/config model=gpt-4 temperature=0.7"
+        v = get_query_command(query)
+        
+        config = v.config
+        assert isinstance(config, dict)
+        assert config["model"] == "gpt-4"
+        assert config["temperature"] == "0.7"
+    
+    def test_query_command_mixed_args_kwargs(self):
+        """测试混合参数的命令"""
+        query = "/deploy myapp env=prod version=1.0"
+        v = get_query_command(query)
+        
+        # deploy 命令有位置参数和键值对参数
+        # 当有kwargs时，返回kwargs
+        deploy_info = v.get_command_info("deploy")
+        assert deploy_info["args"] == ["myapp"]
+        assert deploy_info["kwargs"] == {"env": "prod", "version": "1.0"}
+    
+    def test_query_command_has_command(self):
+        """测试 has_command 方法"""
+        query = "/model gpt-4 /task-prefix mytask"
+        v = get_query_command(query)
+        
+        assert v.has_command("model") == True
+        assert v.has_command("task-prefix") == True
+        assert v.has_command("task_prefix") == True  # 也可以用下划线形式
+        assert v.has_command("nonexistent") == False
+    
+    def test_query_command_get_all_commands(self):
+        """测试 get_all_commands 方法"""
+        query = "/first /second /third"
+        v = get_query_command(query)
+        
+        commands = v.get_all_commands()
+        assert commands == ["first", "second", "third"]
+    
+    def test_query_command_nonexistent_attribute(self):
+        """测试访问不存在的属性"""
+        query = "/model gpt-4"
+        v = get_query_command(query)
+        
+        assert v.model == "gpt-4"
+        assert v.nonexistent is None
+    
+    def test_query_command_empty_command(self):
+        """测试空参数的命令"""
+        query = "/start /stop /restart"
+        v = get_query_command(query)
+        
+        assert v.start == ""
+        assert v.stop == ""
+        assert v.restart == ""
+    
+    def test_query_command_complex_scenario(self):
+        """测试复杂场景"""
+        query = '/async /model gpt-4-turbo /task-prefix analysis "Process the following data" with multiple words'
+        v = get_query_command(query, sub_commands=["model", "task-prefix"])
+        
+        assert v.model == "gpt-4-turbo"
+        assert v.task_prefix == "analysis"  # 第一个参数
+        assert v.query == 'Process the following data with multiple words'  # 剩余参数
+    
+    def test_query_command_last_command_not_in_list(self):
+        """测试最后一个命令不在子命令列表中"""
+        query = "/model gpt-4 /other command /final arg1 arg2 arg3"
+        v = get_query_command(query, sub_commands=["model"])
+        
+        # model 是子命令但不是最后一个，所以保持原样
+        assert v.model == "gpt-4"
+        # other 和 final 不在子命令列表中，保持原样
+        assert v.other == "command"
+        assert v.final == ["arg1", "arg2", "arg3"]
+        assert v.query == ""
+    
+    def test_query_command_disable_last_takes_rest(self):
+        """测试禁用 last_command_takes_rest"""
+        query = "/model gpt-4 /task-prefix mytask arg1 arg2"
+        v = get_query_command(query, 
+                            sub_commands=["model", "task-prefix"],
+                            last_command_takes_rest=False)
+        
+        # 禁用了特殊处理，所以所有参数都保留
+        assert v.model == "gpt-4"
+        assert v.task_prefix == ["mytask", "arg1", "arg2"]
+        assert v.query == ""
+    
+    def test_query_command_repr(self):
+        """测试 __repr__ 方法"""
+        query = "/model gpt-4 /task-prefix mytask hello"
+        v = get_query_command(query, sub_commands=["task-prefix"])
+        
+        repr_str = repr(v)
+        assert "QueryCommand" in repr_str
+        assert "model" in repr_str
+        assert "task-prefix" in repr_str
+
+
 if __name__ == "__main__":
     # 可以直接运行此文件进行测试
     pytest.main([__file__, "-v"])

autocoder/common/ac_style_command_parser/test_typed_parser.py

@@ -0,0 +1,342 @@
+import pytest
+from typing import List, Dict, Any
+
+from .config import (
+    ConfigBuilder,
+    create_config
+)
+
+from .typed_parser import (
+    ParsedCommand,
+    TypedCommandParser,
+    parse_typed_query
+)
+
+
+class TestTypedCommandParser:
+    """测试 TypedCommandParser 类"""
+
+    def test_basic_typed_parsing(self):
+        """测试基本的类型化解析"""
+        config = (create_config()
+                  .command("model")
+                  .positional("name", required=True)
+                  .command("config")
+                  .keyword("temperature", type=float)
+                  .keyword("max_tokens", type=int)
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+        result = parser.parse_typed(
+            "/model gpt-4 /config temperature=0.8 max_tokens=100")
+
+        assert "model" in result
+        assert result["model"].args == ["gpt-4"]
+        assert result["model"].is_valid
+
+        assert "config" in result
+        assert result["config"].kwargs["temperature"] == 0.8  # 转换为float
+        assert result["config"].kwargs["max_tokens"] == 100  # 转换为int
+        assert result["config"].is_valid
+
+    def test_typed_parsing_with_validation_errors(self):
+        """测试带验证错误的类型化解析"""
+        config = (create_config()
+                  .command("model")
+                  .positional("name", required=True, choices=["gpt-3.5", "gpt-4"])
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+        result = parser.parse_typed("/model gpt-5")
+
+        assert "model" in result
+        assert not result["model"].is_valid
+        assert len(result["model"].errors) > 0
+
+    def test_typed_parsing_with_defaults(self):
+        """测试带默认值的类型化解析"""
+        config = (create_config()
+                  .command("config")
+                  .keyword("temperature", type=float, default=0.7)
+                  .keyword("max_tokens", type=int, default=100)
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+        result = parser.parse_typed("/config temperature=0.9")
+
+        assert result["config"].kwargs["temperature"] == 0.9
+        assert result["config"].kwargs["max_tokens"] == 100  # 使用默认值
+
+    def test_typed_parsing_with_remainder(self):
+        """测试收集剩余参数的类型化解析"""
+        config = (create_config()
+                  .command("task")
+                  .positional("prefix", required=True)
+                  .collect_remainder("query")
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+        result = parser.parse_typed("/task mytask this is the query")
+
+        assert result["task"].args == ["mytask"]
+        assert result["task"].remainder == "this is the query"
+
+    def test_typed_parsing_strict_mode(self):
+        """测试严格模式"""
+        config = (create_config()
+                  .strict(True)
+                  .command("known")
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+        result = parser.parse_typed("/known /unknown")
+
+        assert result["known"].is_valid
+        assert not result["unknown"].is_valid
+        assert "Unknown command" in result["unknown"].errors[0]
+
+    def test_bool_type_conversion(self):
+        """测试布尔类型转换"""
+        config = (create_config()
+                  .command("flags")
+                  .keyword("verbose", type=bool)
+                  .keyword("debug", type=bool)
+                  .build()
+                  )
+
+        parser = TypedCommandParser(config)
+
+        # 测试各种布尔值表示
+        result = parser.parse_typed("/flags verbose=true debug=false")
+        assert result["flags"].kwargs["verbose"] is True
+        assert result["flags"].kwargs["debug"] is False
+
+        result = parser.parse_typed("/flags verbose=1 debug=0")
+        assert result["flags"].kwargs["verbose"] is True
+        assert result["flags"].kwargs["debug"] is False
+
+        result = parser.parse_typed("/flags verbose=yes debug=no")
+        assert result["flags"].kwargs["verbose"] is True
+        assert result["flags"].kwargs["debug"] is False
+
+
+class TestTypedQueryCommand:
+    """测试 TypedQueryCommand 类"""
+
+    def test_basic_typed_query_command(self):
+        """测试基本的类型化查询命令"""
+        config = (create_config()
+                  .command("model")
+                  .positional("name", required=True)
+                  .command("temperature")
+                  # value 名字比较特殊，作为位置参数，可以直接通过 result.temperature 访问
+                  .positional("value", type=float)
+                  .build()
+                  )
+
+        result = parse_typed_query("/model gpt-4 /temperature 0.8", config)
+
+        assert result.model.name == "gpt-4"
+        assert result.temperature == 0.8
+        assert isinstance(result.temperature, float)
+
+    def test_typed_query_command_with_remainder(self):
+        """测试带剩余参数的类型化查询命令"""
+        config = (create_config()
+                  .command("task")
+                  .positional("prefix", required=True)
+                  .collect_remainder("query")
+                  .build()
+                  )
+
+        result = parse_typed_query("/task mytask this is the query", config)
+
+        assert result.task.prefix == "mytask"
+        assert result.task.query == "this is the query"
+
+    def test_typed_query_command_validation(self):
+        """测试类型化查询命令的验证"""
+        config = (create_config()
+                  .command("model")
+                  .positional("name", required=True, choices=["gpt-3.5", "gpt-4"])
+                  .build()
+                  )
+
+        result = parse_typed_query("/model gpt-5", config)
+
+        assert not result.is_valid()
+        errors = result.get_errors()
+        assert "model" in errors
+
+    def test_typed_query_command_get_command(self):
+        """测试获取解析后的命令对象"""
+        config = (create_config()
+                  .command("config")
+                  .keyword("temperature", type=float)
+                  .build()
+                  )
+
+        result = parse_typed_query("/config temperature=0.8", config)
+
+        parsed_cmd = result.get_command("config")
+        assert isinstance(parsed_cmd, ParsedCommand)
+        assert parsed_cmd.name == "config"
+        assert parsed_cmd.kwargs["temperature"] == 0.8
+
+    def test_typed_query_command_hyphen_conversion(self):
+        """测试连字符转换"""
+        config = (create_config()
+                  .command("task-prefix")
+                  # value 名字比较特殊，作为位置参数，可以直接通过 result.task_prefix 访问
+                  .positional("value")
+                  .build()
+                  )
+
+        result = parse_typed_query("/task-prefix mytask", config)
+
+        # 可以用下划线访问
+        assert result.task_prefix == "mytask"
+        assert result.has_command("task-prefix")
+        assert result.has_command("task_prefix")
+
+
+class TestIntegrationScenarios:
+    """集成测试场景"""    
+    def test_validation_and_error_reporting(self):
+        """测试验证和错误报告"""
+        config = (create_config()
+                  .strict(True)  # 严格模式
+                  .command("deploy")
+                  .positional("app", required=True)
+                  .keyword("env", required=True, choices=["dev", "staging", "prod"])
+                  .keyword("version", required=True)
+                  .build()
+                  )
+
+        # 缺少必需参数
+        result = parse_typed_query("/deploy myapp", config)
+        assert not result.is_valid()
+        errors = result.get_errors()
+        assert "deploy" in errors
+        assert any("env" in e for e in errors["deploy"])
+
+        # 无效的选项值
+        result = parse_typed_query(
+            "/deploy myapp env=test version=1.0", config)
+        assert not result.is_valid()
+        errors = result.get_errors()
+        assert any("must be one of" in e for e in errors["deploy"])
+
+        # 未知命令（严格模式）
+        result = parse_typed_query("/unknown", config)
+        assert not result.is_valid()
+        errors = result.get_errors()
+        assert "unknown" in errors
+
+
+class TestCommandLevelRemainder:
+    """测试命令级别的剩余参数收集"""        
+    def test_async_command_scenario(self):
+        global_config = (create_config()
+                         .collect_remainder("query")
+                         .command("async")
+                         .max_args(0)
+                         .command("model")
+                         # 用 name 也可以；用 "value" 可直接 result.model 返回值
+                         .positional("value", required=True)
+                         .max_args(1)
+                         .command("loop")
+                         .positional("value", type=int)
+                         .command("name")
+                         .max_args(1)                         
+                         .build()
+                         )
+
+        result = parse_typed_query(
+            "/async /model gpt-4 /loop 3 /name task-01 analysis Process the data", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"
+
+        result = parse_typed_query(
+            "/async /model gpt-4 /name task-01 /loop 3 analysis Process the data", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"
+
+        result = parse_typed_query(
+            "/async /name task-01 /model gpt-4 /loop 3 analysis Process the data", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"
+
+    def test_quoted_string_scenario(self):
+        global_config = (create_config()
+                         .collect_remainder("query")
+                         .command("async")
+                         .max_args(0)
+                         .command("model")
+                         # 用 name 也可以；用 "value" 可直接 result.model 返回值
+                         .positional("value", required=True)
+                         .max_args(1)
+                         .command("loop")
+                         .positional("value", type=int)
+                         .command("name")
+                         .max_args(1)    
+                         .command("wow") 
+                         .keyword("name", type=str)
+                         .keyword("x", type=str)
+                         .build()
+                         )
+
+        result = parse_typed_query(
+            "/async /model gpt-4 /loop 3 /name task-01 \"analysis Process the data\"", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"
+
+        result = parse_typed_query(
+            "/async /model gpt-4 /name task-01 /loop 3 \"analysis Process the data\"", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"
+
+        result = parse_typed_query(
+            "/async /name task-01 /model gpt-4 /loop 3 \"\"\"analysis Process the data\"\"\"", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data"       
+
+
+        result = parse_typed_query(
+            "/async /name task-01 /model gpt-4 /wow name=test x=\"analysis2 Process the data\" /loop 3 \"\"\"analysis Process the data\"\"\"", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data" 
+        assert result.wow.name == "test"
+        assert result.wow.x == "analysis2 Process the data"
+
+
+        result = parse_typed_query(
+            "/async /name task-01 /model gpt-4 /wow name=test x=\"\"\"analysis2 \Process the data\"\"\" /loop 3 \"\"\"analysis Process the data\"\"\"", global_config)
+        assert result.model == "gpt-4"
+        assert result.loop == 3
+        assert result.name == "task-01"
+        assert result.query == "analysis Process the data" 
+        assert result.wow.name == "test"
+        assert result.wow.x == "analysis2 \Process the data"
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])