fix: render microflow activity bodies in diff-local output

diff-local emitted a hardcoded `-- (microflow body)` stub for every
microflow, so both sides of the diff were identical and the actual
changes were invisible. Replace the stub with the same renderer used
by DESCRIBE MICROFLOW.

- Extract ParseMicroflowBSON / ParseMicroflowFromRaw as standalone
  functions so non-Reader callers (git-history BSON blobs) can parse
  microflows without an mpr.Reader.
- Factor renderMicroflowMDL out of describeMicroflowToString as a
  shared emitter; DESCRIBE still populates the ELK source map, diff
  callers pass nil.
- Wire diff-local's microflowBsonToMDL through the shared renderer
  with a name-lookup helper that resolves entity/microflow IDs
  against the working-tree model.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ako

mdl/executor/cmd_diff_local.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/mendixlabs/mxcli/mdl/ast"
 	"github.com/mendixlabs/mxcli/model"
+	"github.com/mendixlabs/mxcli/sdk/mpr"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
@@ -484,55 +485,54 @@ func (e *Executor) attributeBsonToMDL(raw map[string]any) string {
 	return result.String()
 }
 
-// microflowBsonToMDL converts a microflow BSON to MDL
+// microflowBsonToMDL converts a microflow BSON to MDL using the same
+// renderer as DESCRIBE MICROFLOW, so diffs include activity bodies.
+// Falls back to a header-only stub if parsing fails.
 func (e *Executor) microflowBsonToMDL(raw map[string]any, qualifiedName string) string {
-	var lines []string
+	qn := splitQualifiedName(qualifiedName)
+	mf := mpr.ParseMicroflowFromRaw(raw, model.ID(qn.Name), "")
 
-	// Documentation
-	if doc := extractString(raw["Documentation"]); doc != "" {
-		lines = append(lines, "/**")
-		lines = append(lines, " * "+doc)
-		lines = append(lines, " */")
+	entityNames, microflowNames := e.buildNameLookups()
+	return e.renderMicroflowMDL(mf, qn, entityNames, microflowNames, nil)
+}
+
+// splitQualifiedName parses "Module.Name" into an ast.QualifiedName.
+// If no module prefix is present, Module is empty.
+func splitQualifiedName(qualifiedName string) ast.QualifiedName {
+	if idx := strings.LastIndex(qualifiedName, "."); idx > 0 {
+		return ast.QualifiedName{Module: qualifiedName[:idx], Name: qualifiedName[idx+1:]}
 	}
+	return ast.QualifiedName{Name: qualifiedName}
+}
 
-	lines = append(lines, fmt.Sprintf("CREATE MICROFLOW %s (", qualifiedName))
-
-	// Parameters - look in ObjectCollection
-	if objCollection, ok := raw["ObjectCollection"].(map[string]any); ok {
-		objects := extractBsonArray(objCollection["Objects"])
-		for i, obj := range objects {
-			if objMap, ok := obj.(map[string]any); ok {
-				if objType := extractString(objMap["$Type"]); strings.Contains(objType, "MicroflowParameterObject") {
-					paramName := extractString(objMap["Name"])
-					paramType := "Object"
-					if typeStr := extractString(objMap["VariableType"]); typeStr != "" {
-						paramType = typeStr
-					}
-					comma := ","
-					if i == len(objects)-1 {
-						comma = ""
-					}
-					lines = append(lines, fmt.Sprintf("  $%s: %s%s", paramName, paramType, comma))
-				}
+// buildNameLookups builds ID → qualified-name maps for entities and
+// microflows from the current project. Used by BSON-driven renderers that
+// receive IDs (e.g. entity references) and want to resolve them against
+// the working-tree model. Returns empty maps if the reader is unavailable.
+func (e *Executor) buildNameLookups() (map[model.ID]string, map[model.ID]string) {
+	entityNames := make(map[model.ID]string)
+	microflowNames := make(map[model.ID]string)
+	if e.reader == nil {
+		return entityNames, microflowNames
+	}
+	h, err := e.getHierarchy()
+	if err != nil {
+		return entityNames, microflowNames
+	}
+	if domainModels, err := e.reader.ListDomainModels(); err == nil {
+		for _, dm := range domainModels {
+			modName := h.GetModuleName(dm.ContainerID)
+			for _, entity := range dm.Entities {
+				entityNames[entity.ID] = modName + "." + entity.Name
 			}
 		}
 	}
-
-	lines = append(lines, ")")
-
-	// Return type
-	returnType := "Void"
-	if rt := extractString(raw["ReturnType"]); rt != "" {
-		returnType = rt
+	if microflows, err := e.reader.ListMicroflows(); err == nil {
+		for _, mf := range microflows {
+			microflowNames[mf.ID] = h.GetQualifiedName(mf.ContainerID, mf.Name)
+		}
 	}
-	lines = append(lines, fmt.Sprintf("RETURNS %s", returnType))
-
-	lines = append(lines, "BEGIN")
-	lines = append(lines, "  -- (microflow body)")
-	lines = append(lines, "END;")
-	lines = append(lines, "/")
-
-	return strings.Join(lines, "\n")
+	return entityNames, microflowNames
 }
 
 // nanoflowBsonToMDL converts a nanoflow BSON to MDL

mdl/executor/cmd_microflows_show.go

@@ -458,26 +458,49 @@ func (e *Executor) describeMicroflowToString(name ast.QualifiedName) (string, ma
 		return "", nil, fmt.Errorf("microflow not found: %s", name)
 	}
 
+	sourceMap := make(map[string]elkSourceRange)
+	mdl := e.renderMicroflowMDL(targetMf, name, entityNames, microflowNames, sourceMap)
+	return mdl, sourceMap, nil
+}
+
+// renderMicroflowMDL formats a parsed Microflow as MDL text.
+//
+// Shared by DESCRIBE MICROFLOW and `diff-local`, so both paths produce the
+// same output. entityNames/microflowNames provide ID → qualified-name
+// resolution; pass empty maps if unavailable (types will fall back to
+// "Object"/"List" stubs). If sourceMap is non-nil it will be populated with
+// ELK node IDs → line ranges for visualization; pass nil when not needed.
+func (e *Executor) renderMicroflowMDL(
+	mf *microflows.Microflow,
+	name ast.QualifiedName,
+	entityNames map[model.ID]string,
+	microflowNames map[model.ID]string,
+	sourceMap map[string]elkSourceRange,
+) string {
 	var lines []string
 
-	if targetMf.Documentation != "" {
+	if mf.Documentation != "" {
 		lines = append(lines, "/**")
-		for docLine := range strings.SplitSeq(targetMf.Documentation, "\n") {
+		for docLine := range strings.SplitSeq(mf.Documentation, "\n") {
 			lines = append(lines, " * "+docLine)
 		}
 		lines = append(lines, " */")
 	}
 
+	if mf.Excluded {
+		lines = append(lines, "@excluded")
+	}
+
 	qualifiedName := name.Module + "." + name.Name
-	if len(targetMf.Parameters) > 0 {
+	if len(mf.Parameters) > 0 {
 		lines = append(lines, fmt.Sprintf("CREATE OR MODIFY MICROFLOW %s (", qualifiedName))
-		for i, param := range targetMf.Parameters {
+		for i, param := range mf.Parameters {
 			paramType := "Object"
 			if param.Type != nil {
 				paramType = e.formatMicroflowDataType(param.Type, entityNames)
 			}
 			comma := ","
-			if i == len(targetMf.Parameters)-1 {
+			if i == len(mf.Parameters)-1 {
 				comma = ""
 			}
 			lines = append(lines, fmt.Sprintf("  $%s: %s%s", param.Name, paramType, comma))
@@ -487,24 +510,27 @@ func (e *Executor) describeMicroflowToString(name ast.QualifiedName) (string, ma
 		lines = append(lines, fmt.Sprintf("CREATE OR MODIFY MICROFLOW %s ()", qualifiedName))
 	}
 
-	if targetMf.ReturnType != nil {
-		returnType := e.formatMicroflowDataType(targetMf.ReturnType, entityNames)
+	if mf.ReturnType != nil {
+		returnType := e.formatMicroflowDataType(mf.ReturnType, entityNames)
 		if returnType != "Void" && returnType != "" {
 			returnLine := fmt.Sprintf("RETURNS %s", returnType)
-			if targetMf.ReturnVariableName != "" && targetMf.ReturnVariableName != "Variable" {
-				returnLine += fmt.Sprintf(" AS $%s", targetMf.ReturnVariableName)
+			if mf.ReturnVariableName != "" && mf.ReturnVariableName != "Variable" {
+				returnLine += fmt.Sprintf(" AS $%s", mf.ReturnVariableName)
 			}
 			lines = append(lines, returnLine)
 		}
 	}
 
 	lines = append(lines, "BEGIN")
-	headerLineCount := len(lines) // lines before activity body
+	headerLineCount := len(lines)
 
-	sourceMap := make(map[string]elkSourceRange)
-
-	if targetMf.ObjectCollection != nil && len(targetMf.ObjectCollection.Objects) > 0 {
-		activityLines := e.formatMicroflowActivitiesWithSourceMap(targetMf, entityNames, microflowNames, sourceMap, headerLineCount)
+	if mf.ObjectCollection != nil && len(mf.ObjectCollection.Objects) > 0 {
+		var activityLines []string
+		if sourceMap != nil {
+			activityLines = e.formatMicroflowActivitiesWithSourceMap(mf, entityNames, microflowNames, sourceMap, headerLineCount)
+		} else {
+			activityLines = e.formatMicroflowActivities(mf, entityNames, microflowNames)
+		}
 		for _, line := range activityLines {
 			lines = append(lines, "  "+line)
 		}
@@ -514,9 +540,9 @@ func (e *Executor) describeMicroflowToString(name ast.QualifiedName) (string, ma
 
 	lines = append(lines, "END;")
 
-	if len(targetMf.AllowedModuleRoles) > 0 {
-		roles := make([]string, len(targetMf.AllowedModuleRoles))
-		for i, r := range targetMf.AllowedModuleRoles {
+	if len(mf.AllowedModuleRoles) > 0 {
+		roles := make([]string, len(mf.AllowedModuleRoles))
+		for i, r := range mf.AllowedModuleRoles {
 			roles[i] = string(r)
 		}
 		lines = append(lines, "")
@@ -526,7 +552,7 @@ func (e *Executor) describeMicroflowToString(name ast.QualifiedName) (string, ma
 
 	lines = append(lines, "/")
 
-	return strings.Join(lines, "\n"), sourceMap, nil
+	return strings.Join(lines, "\n")
 }
 
 // formatMicroflowDataType formats a microflow data type for MDL output.

sdk/mpr/parser_microflow.go

@@ -19,16 +19,27 @@ func (r *Reader) parseMicroflow(unitID, containerID string, contents []byte) (*m
 	if err != nil {
 		return nil, err
 	}
+	return ParseMicroflowBSON(contents, model.ID(unitID), model.ID(containerID))
+}
 
+// ParseMicroflowBSON parses raw microflow BSON bytes into a Microflow.
+// Unlike (*Reader).parseMicroflow it does not require a Reader, so it can
+// parse arbitrary blobs (e.g. historical versions read via `git show`).
+func ParseMicroflowBSON(contents []byte, unitID, containerID model.ID) (*microflows.Microflow, error) {
 	var raw map[string]any
 	if err := bson.Unmarshal(contents, &raw); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal BSON: %w", err)
 	}
+	return ParseMicroflowFromRaw(raw, unitID, containerID), nil
+}
 
+// ParseMicroflowFromRaw builds a Microflow from an already-unmarshalled BSON map.
+// Useful when the caller already has the decoded map (e.g. diff-local).
+func ParseMicroflowFromRaw(raw map[string]any, unitID, containerID model.ID) *microflows.Microflow {
 	mf := &microflows.Microflow{}
-	mf.ID = model.ID(unitID)
+	mf.ID = unitID
 	mf.TypeName = "Microflows$Microflow"
-	mf.ContainerID = model.ID(containerID)
+	mf.ContainerID = containerID
 
 	if name, ok := raw["Name"].(string); ok {
 		mf.Name = name
@@ -128,7 +139,7 @@ func (r *Reader) parseMicroflow(unitID, containerID string, contents []byte) (*m
 		}
 	}
 
-	return mf, nil
+	return mf
 }
 
 // parseSequenceFlow parses a SequenceFlow from raw BSON data.