Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

【架构优化】从 materializeInvocationForDriver 中拆出 materializeAgentRules 与 materializeMCPDefinitions (#684) (#685)

fx-kurumic780be262e29
diff --git a/internal/runtime/materialize.go b/internal/runtime/materialize.go
index ef20eb37..ea1dd369 100644
--- a/internal/runtime/materialize.go
+++ b/internal/runtime/materialize.go
@@ -110,22 +110,11 @@ func materializeInvocationForDriver(workspace, invocationID string, ex domain.Ex
return compiled, err
}
}
- lines := []string{"# " + a.Name, "", "## Rules"}
- sort.Slice(assets.Rules, func(i, j int) bool { return assets.Rules[i].Priority > assets.Rules[j].Priority })
- for _, v := range assets.Rules {
- ruleID := safeID(v.ID)
- if ruleID == "" {
- return compiled, fmt.Errorf("rule id is required")
- }
- ruleFile := filepath.Join(workspace, ".agentflow", "rules", ruleID+".md")
- if err := writeManagedFile(workspace, ruleFile, []byte(v.Content), 0o600); err != nil {
- return compiled, err
- }
- if err := replaceRelativeSymlink(filepath.Join(bindingRoot, "rules", ruleID+".md"), filepath.Join("..", "..", "..", "rules", ruleID+".md")); err != nil {
- return compiled, err
- }
- lines = append(lines, "", "### "+v.Name, v.Content)
+ ruleLines, err := materializeAgentRules(workspace, bindingRoot, assets.Rules)
+ if err != nil {
+ return compiled, err
}
+ lines := append([]string{"# " + a.Name, "", "## Rules"}, ruleLines...)
selectedSkills := make([]selectedSkill, 0, len(assets.Skills))
for _, skill := range assets.Skills {
item, err := compileSelectedSkill(agentRel, skill, assets.SkillFiles[skill.ID])
@@ -188,18 +177,8 @@ func materializeInvocationForDriver(workspace, invocationID string, ex domain.Ex
return compiled, err
}
}
- for _, server := range mergedMCP {
- serverID := safeID(server.ID)
- if serverID == "" {
- return compiled, fmt.Errorf("MCP server id is required")
- }
- definition, _ := json.MarshalIndent(server, "", " ")
- if err := writeManagedFile(workspace, filepath.Join(workspace, ".agentflow", "mcp", serverID+".json"), definition, 0o600); err != nil {
- return compiled, err
- }
- if err := replaceRelativeSymlink(filepath.Join(bindingRoot, "mcp", serverID+".json"), filepath.Join("..", "..", "..", "mcp", serverID+".json")); err != nil {
- return compiled, err
- }
+ if err := materializeMCPDefinitions(workspace, bindingRoot, mergedMCP); err != nil {
+ return compiled, err
}
runtimeMCP := prepareMCPServersForDriver(mergedMCP, driver)
entries, err := mcpConfigEntries(runtimeMCP)
@@ -222,6 +201,48 @@ func materializeInvocationForDriver(workspace, invocationID string, ex domain.Ex
return compiled, err
}
+// materializeAgentRules writes each rule into the shared .agentflow/rules
+// catalog, links it from the Agent's bindings, and returns the rule sections
+// for agent-system.md. Rules are sorted in place by descending priority.
+func materializeAgentRules(workspace, bindingRoot string, rules []domain.RuleDefinition) ([]string, error) {
+ sort.Slice(rules, func(i, j int) bool { return rules[i].Priority > rules[j].Priority })
+ var lines []string
+ for _, v := range rules {
+ ruleID := safeID(v.ID)
+ if ruleID == "" {
+ return nil, fmt.Errorf("rule id is required")
+ }
+ ruleFile := filepath.Join(workspace, ".agentflow", "rules", ruleID+".md")
+ if err := writeManagedFile(workspace, ruleFile, []byte(v.Content), 0o600); err != nil {
+ return nil, err
+ }
+ if err := replaceRelativeSymlink(filepath.Join(bindingRoot, "rules", ruleID+".md"), filepath.Join("..", "..", "..", "rules", ruleID+".md")); err != nil {
+ return nil, err
+ }
+ lines = append(lines, "", "### "+v.Name, v.Content)
+ }
+ return lines, nil
+}
+
+// materializeMCPDefinitions writes each MCP server definition into the shared
+// .agentflow/mcp catalog and links it from the Agent's bindings.
+func materializeMCPDefinitions(workspace, bindingRoot string, servers []domain.MCPServerDefinition) error {
+ for _, server := range servers {
+ serverID := safeID(server.ID)
+ if serverID == "" {
+ return fmt.Errorf("MCP server id is required")
+ }
+ definition, _ := json.MarshalIndent(server, "", " ")
+ if err := writeManagedFile(workspace, filepath.Join(workspace, ".agentflow", "mcp", serverID+".json"), definition, 0o600); err != nil {
+ return err
+ }
+ if err := replaceRelativeSymlink(filepath.Join(bindingRoot, "mcp", serverID+".json"), filepath.Join("..", "..", "..", "mcp", serverID+".json")); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
func ensureDirectoryNoSymlink(path string, mode os.FileMode) error {
info, err := os.Lstat(path)
if err == nil {
diff --git a/internal/runtime/materialize_bindings_test.go b/internal/runtime/materialize_bindings_test.go
new file mode 100644
index 00000000..2dfbd768
--- /dev/null
+++ b/internal/runtime/materialize_bindings_test.go
@@ -0,0 +1,105 @@
+package runtime
+
+import (
+ "os"
+ "path/filepath"
+ "reflect"
+ "strings"
+ "testing"
+
+ "agentflow/internal/domain"
+)
+
+func prepareBindingRoot(t *testing.T, workspace string) string {
+ t.Helper()
+ for _, dir := range []string{"rules", "mcp", "bindings"} {
+ if _, err := EnsureControlDirectory(workspace, dir); err != nil {
+ t.Fatal(err)
+ }
+ }
+ bindingRoot, err := resetControlDirectory(workspace, "bindings", "fixer")
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, kind := range []string{"rules", "mcp"} {
+ if err := os.Mkdir(filepath.Join(bindingRoot, kind), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ }
+ return bindingRoot
+}
+
+func TestMaterializeAgentRulesSortsWritesAndLinks(t *testing.T) {
+ workspace := t.TempDir()
+ bindingRoot := prepareBindingRoot(t, workspace)
+ rules := []domain.RuleDefinition{
+ {ID: "low", Name: "Low", Content: "low body", Priority: 1},
+ {ID: "high", Name: "High", Content: "high body", Priority: 9},
+ }
+ lines, err := materializeAgentRules(workspace, bindingRoot, rules)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := []string{"", "### High", "high body", "", "### Low", "low body"}
+ if !reflect.DeepEqual(lines, want) {
+ t.Fatalf("rule lines = %q, want %q", lines, want)
+ }
+ if rules[0].ID != "high" {
+ t.Fatalf("rules should be sorted in place by priority, got %q first", rules[0].ID)
+ }
+ for _, rule := range rules {
+ content, err := os.ReadFile(filepath.Join(bindingRoot, "rules", rule.ID+".md"))
+ if err != nil || string(content) != rule.Content {
+ t.Fatalf("rule %s not reachable through binding: %q %v", rule.ID, content, err)
+ }
+ target, err := os.Readlink(filepath.Join(bindingRoot, "rules", rule.ID+".md"))
+ if err != nil || target != filepath.Join("..", "..", "..", "rules", rule.ID+".md") {
+ t.Fatalf("rule %s link target = %q %v", rule.ID, target, err)
+ }
+ }
+}
+
+func TestMaterializeAgentRulesRequiresID(t *testing.T) {
+ workspace := t.TempDir()
+ bindingRoot := prepareBindingRoot(t, workspace)
+ _, err := materializeAgentRules(workspace, bindingRoot, []domain.RuleDefinition{{ID: "", Name: "Nameless"}})
+ if err == nil || err.Error() != "rule id is required" {
+ t.Fatalf("expected rule id error, got %v", err)
+ }
+}
+
+func TestMaterializeAgentRulesEmpty(t *testing.T) {
+ workspace := t.TempDir()
+ bindingRoot := prepareBindingRoot(t, workspace)
+ lines, err := materializeAgentRules(workspace, bindingRoot, nil)
+ if err != nil || len(lines) != 0 {
+ t.Fatalf("empty rules = %q %v", lines, err)
+ }
+}
+
+func TestMaterializeMCPDefinitionsWritesAndLinks(t *testing.T) {
+ workspace := t.TempDir()
+ bindingRoot := prepareBindingRoot(t, workspace)
+ servers := []domain.MCPServerDefinition{{ID: "docs", Name: "Docs"}}
+ if err := materializeMCPDefinitions(workspace, bindingRoot, servers); err != nil {
+ t.Fatal(err)
+ }
+ link := filepath.Join(bindingRoot, "mcp", "docs.json")
+ target, err := os.Readlink(link)
+ if err != nil || target != filepath.Join("..", "..", "..", "mcp", "docs.json") {
+ t.Fatalf("mcp link target = %q %v", target, err)
+ }
+ raw, err := os.ReadFile(link)
+ if err != nil || !strings.Contains(string(raw), `"docs"`) {
+ t.Fatalf("mcp definition not reachable through binding: %s %v", raw, err)
+ }
+}
+
+func TestMaterializeMCPDefinitionsRequiresID(t *testing.T) {
+ workspace := t.TempDir()
+ bindingRoot := prepareBindingRoot(t, workspace)
+ err := materializeMCPDefinitions(workspace, bindingRoot, []domain.MCPServerDefinition{{ID: " "}})
+ if err == nil || err.Error() != "MCP server id is required" {
+ t.Fatalf("expected MCP server id error, got %v", err)
+ }
+}