@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/model/routing.rs

@@ -27,8 +27,7 @@ static WHEN_EQ: LazyLock<Option<Regex>> =
     LazyLock::new(|| Regex::new(r#"^task\.(type|risk)\s*==\s*['"]([^'"]+)['"]\z"#).ok());
 static WHEN_FILES: LazyLock<Option<Regex>> =
     LazyLock::new(|| Regex::new(r"^task\.files\s+matches\s+\[(.*)\]\z").ok());
-static QUOTED: LazyLock<Option<Regex>> =
-    LazyLock::new(|| Regex::new(r#"['"]([^'"]+)['"]"#).ok());
+static QUOTED: LazyLock<Option<Regex>> = LazyLock::new(|| Regex::new(r#"['"]([^'"]+)['"]"#).ok());
 
 /// `routing.route_task(spec, task)`。
 pub fn route_task(spec: &Yaml, task: &Yaml) -> RouteResult {
@@ -41,11 +40,18 @@ pub fn route_task(spec: &Yaml, task: &Yaml) -> RouteResult {
     // valid_agents = {leader_id} ∪ {agent.id}
     let agents: &[Yaml] = spec.get("agents").and_then(Yaml::as_list).unwrap_or(&[]);
     let valid = |id: &str| {
-        id == leader_id || agents.iter().any(|a| a.get("id").and_then(Yaml::as_str) == Some(id))
+        id == leader_id
+            || agents
+                .iter()
+                .any(|a| a.get("id").and_then(Yaml::as_str) == Some(id))
     };
 
     // explicit assignee(truthy)。
-    if let Some(explicit) = task.get("assignee").and_then(Yaml::as_str).filter(|s| !s.is_empty()) {
+    if let Some(explicit) = task
+        .get("assignee")
+        .and_then(Yaml::as_str)
+        .filter(|s| !s.is_empty())
+    {
         if valid(explicit) {
             return RouteResult {
                 agent_id: AgentId::from(explicit),
@@ -70,7 +76,10 @@ pub fn route_task(spec: &Yaml, task: &Yaml) -> RouteResult {
 
     for rule in rules {
         if rule_matches(rule, task) {
-            let id = rule.get("assign_to").and_then(Yaml::as_str).unwrap_or(leader_id);
+            let id = rule
+                .get("assign_to")
+                .and_then(Yaml::as_str)
+                .unwrap_or(leader_id);
             let rule_id = rule.get("id").and_then(Yaml::as_str).unwrap_or("<unnamed>");
             return RouteResult {
                 agent_id: AgentId::from(id),
@@ -98,7 +107,10 @@ fn rule_matches(rule: &Yaml, task: &Yaml) -> bool {
     }
     if let Some(when) = rule.get("when").filter(|w| w.is_truthy()) {
         // Python str(when):when 通常是字符串;非字符串退化为其 Debug(极少见)。
-        let expr = when.as_str().map(str::to_string).unwrap_or_else(|| format!("{when:?}"));
+        let expr = when
+            .as_str()
+            .map(str::to_string)
+            .unwrap_or_else(|| format!("{when:?}"));
         if !when_match(&expr, task) {
             return false;
         }
@@ -136,7 +148,10 @@ fn structured_match(m: &Yaml, task: &Yaml) -> bool {
         }
     }
     if let Some(files_pat) = m.get("files") {
-        let patterns: Vec<&str> = as_list(files_pat).iter().filter_map(|v| v.as_str()).collect();
+        let patterns: Vec<&str> = as_list(files_pat)
+            .iter()
+            .filter_map(|v| v.as_str())
+            .collect();
         let files: Vec<&str> = task
             .get("files")
             .and_then(Yaml::as_list)
@@ -156,7 +171,10 @@ fn when_match(expr: &str, task: &Yaml) -> bool {
     if let Some(re) = WHEN_TYPE_IN.as_ref() {
         if let Some(c) = re.captures(expr) {
             let values = quoted_values(c.get(1).map_or("", |m| m.as_str()));
-            return task.get("type").and_then(Yaml::as_str).is_some_and(|t| values.iter().any(|v| v == t));
+            return task
+                .get("type")
+                .and_then(Yaml::as_str)
+                .is_some_and(|t| values.iter().any(|v| v == t));
         }
     }
     if let Some(re) = WHEN_EQ.as_ref() {
@@ -234,7 +252,8 @@ fn fnmatch_translate(pat: &str) -> String {
                 if j >= n {
                     body.push_str("\\[");
                 } else {
-                    let mut stuff: String = chars[i..j].iter().collect::<String>().replace('\\', "\\\\");
+                    let mut stuff: String =
+                        chars[i..j].iter().collect::<String>().replace('\\', "\\\\");
                     i = j + 1;
                     if let Some(rest) = stuff.strip_prefix('!') {
                         stuff = format!("^{rest}");
@@ -254,7 +273,11 @@ fn fnmatch_translate(pat: &str) -> String {
 
 /// Python `repr()` of a str(简化:identifier 类用单引号,含单引号无双引号用双引号)。
 fn py_repr_str(s: &str) -> String {
-    let quote = if s.contains('\'') && !s.contains('"') { '"' } else { '\'' };
+    let quote = if s.contains('\'') && !s.contains('"') {
+        '"'
+    } else {
+        '\''
+    };
     let mut out = String::new();
     out.push(quote);
     for c in s.chars() {
@@ -289,12 +312,32 @@ mod tests {
     fn route_task_matches_python_golden() {
         let s = spec();
         let cases: &[(&str, &str, &str)] = &[
-            (r#"{"type":"implementation"}"#, "codex_implementer", "matched routing rule implementation-to-codex"),
-            (r#"{"type":"research"}"#, "codex_researcher", "matched routing rule research-to-codex"),
-            (r#"{"type":"review"}"#, "codex_reviewer", "matched routing rule review-to-codex"),
+            (
+                r#"{"type":"implementation"}"#,
+                "codex_implementer",
+                "matched routing rule implementation-to-codex",
+            ),
+            (
+                r#"{"type":"research"}"#,
+                "codex_researcher",
+                "matched routing rule research-to-codex",
+            ),
+            (
+                r#"{"type":"review"}"#,
+                "codex_reviewer",
+                "matched routing rule review-to-codex",
+            ),
             (r#"{"type":"unknown"}"#, "leader", "no routing rule matched"),
-            (r#"{"assignee":"codex_implementer","type":"x"}"#, "codex_implementer", "explicit assignee on task"),
-            (r#"{"assignee":"ghost","type":"x"}"#, "leader", "unknown explicit assignee 'ghost'"),
+            (
+                r#"{"assignee":"codex_implementer","type":"x"}"#,
+                "codex_implementer",
+                "explicit assignee on task",
+            ),
+            (
+                r#"{"assignee":"ghost","type":"x"}"#,
+                "leader",
+                "unknown explicit assignee 'ghost'",
+            ),
             (r#"{}"#, "leader", "no routing rule matched"),
         ];
         for (t, want_id, want_reason) in cases {
@@ -318,7 +361,8 @@ mod tests {
     #[test]
     fn structured_match_and_files() {
         // 构造带 match dict 的规则,验 type/files。
-        let rule = task(r#"{"id":"r1","assign_to":"w","priority":1,"match":{"files":["src/*.rs"]}}"#);
+        let rule =
+            task(r#"{"id":"r1","assign_to":"w","priority":1,"match":{"files":["src/*.rs"]}}"#);
         assert!(rule_matches(&rule, &task(r#"{"files":["src/main.rs"]}"#)));
         assert!(!rule_matches(&rule, &task(r#"{"files":["docs/x.md"]}"#)));
     }
@@ -328,10 +372,12 @@ mod tests {
         // Backlog control bug: compiler emits one route per agent with match.assignee.
         // match.assignee must be a real predicate; otherwise every route is unconditional and
         // tasks funnel into the first/highest-priority rule.
-        let alpha_rule =
-            task(r#"{"id":"route-alpha","match":{"assignee":["alpha"]},"assign_to":"alpha","priority":10}"#);
-        let bravo_rule =
-            task(r#"{"id":"route-bravo","match":{"assignee":["bravo"]},"assign_to":"bravo","priority":10}"#);
+        let alpha_rule = task(
+            r#"{"id":"route-alpha","match":{"assignee":["alpha"]},"assign_to":"alpha","priority":10}"#,
+        );
+        let bravo_rule = task(
+            r#"{"id":"route-bravo","match":{"assignee":["bravo"]},"assign_to":"bravo","priority":10}"#,
+        );
         let bravo_task = task(r#"{"id":"t1","assignee":"bravo"}"#);
 
         assert!(!rule_matches(&alpha_rule, &bravo_task));