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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
【架构优化】从 materializeInvocationForDriver 中拆出 materializeAgentRules 与 materializeMCPDefinitions (#684) (#685)
fx-kurumic780be262e29
diff --git a/internal/runtime/materialize.go b/internal/runtime/materialize.goindex ef20eb37..ea1dd369 100644--- a/internal/runtime/materialize.go+++ b/internal/runtime/materialize.go@@ -110,22 +110,11 @@ func materializeInvocationForDriver(workspace, invocationID string, ex domain.Exreturn 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.Exreturn 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.Exreturn 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.gonew file mode 100644index 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)+ }+}