mhl-workflows

mhl workflows

The executable unit of mhl. Assumes the mhl-language skill. The design question behind every rule here: what happens when this step runs twice? mhl checkpoints between steps and gives at-least-once execution, so a step can always repeat.

Choose the declaration

Start with pipeline. Move to workflow when a real branch appears: pipeline is a promise to the reader that it runs top to bottom.

Anatomy

Keep this order: description, inputs, const/var/mem, hooks, output, steps.

type ReviewInput = { diff: string, base?: string }
type ReviewOutput = { approved: bool, summary: string }

agent Reviewer {
    command: "echo"
    args: ["${prompt}"]
}

tool Verdict {
    is_clean(review: string): bool -> !review.contains("BLOCKER")
}

workflow ReviewChange(req: ReviewInput): ReviewOutput {
    description: "Reviews a diff and reports whether it can merge."

    var review = ""
    var approved = false

    output: {
        approved: approved
        summary: review
    }

    step Analyze timeout 5m {
        var base = req.base ?? "main"
        self.review = Reviewer.run(prompt: "Review against ${base}: ${req.diff}")
    }

    step Decide {
        self.approved = Verdict.is_clean(review)
        if (!self.approved) goto Reject
        complete()
    }

    step Reject {
        log.warn("blocked:", review)
    }
}

test review_change {
    describe clean_diff_is_approved {
        var result = ReviewChange.run(inputs: {diff: "fix typo"})
        are_equal(result.state, "completed")
        are_equal(result.executed, ["Analyze", "Decide"])
        are_equal(result.output.approved, true)
    }

    describe blocker_takes_the_reject_branch {
        var result = ReviewChange.run(inputs: {diff: "BLOCKER here", base: "dev"})
        are_equal(result.executed, ["Analyze", "Decide", "Reject"])
        are_equal(result.output.approved, false)
    }
}