🥮 mooncakes.io

    moonchange

    Deterministic repository change-policy evaluation and review planning for MoonBit

    change-governance
    code-owners
    review-policy
    ci-gates
    Download zip
    Version
    0.2.1
    License
    MIT
    Repository
    Last updated
    13 hours ago
    Downloads
    2

    Dependencies

    #MoonChange

    MoonChange is an original MoonBit library and CLI for repository change governance. It turns a path-scoped policy plus change evidence into a deterministic review plan and a passed, review, or rejected gate.

    It is designed for maintainers who need policy-as-code for ownership routing, approval quorums, required checks and labels, line budgets, forbidden operations, binary restrictions, and release-note obligations.

    #Why

    Repository review rules are often scattered across CODEOWNERS files, CI YAML, team conventions, and release checklists. MoonChange makes those obligations explicit and testable before a change is merged. The same policy can audit an explicit change manifest or metadata extracted from a Git unified diff.

    MoonChange does not implement a diff algorithm or patch engine. For the optional diff input, it calls the mature mizchi/bit_apply@0.46.4 parse_patches API and converts only its PatchInfo metadata into governance inputs.

    #Capabilities

    • Parse and canonically serialize bounded policy, manifest, and evidence files.
    • Match safe repository-relative paths with *, ?, and whole-segment **.
    • Resolve owners by highest specificity, with the last rule winning ties.
    • Aggregate all matching governance rules rather than selecting only one.
    • Enforce owner approvals, checks, labels, per-path and total line budgets, forbidden operations, binary restrictions, and release-note requirements.
    • Review both source and destination paths for rename operations.
    • Produce stable findings, an aggregate review plan, and CI-oriented exit codes.
    • Emit deterministic versioned JSON for audit, explain, lint, and comparison workflows without changing the default human-readable output.
    • Explain one path, lint ineffective policies, and compare old/new policies for a concrete path inventory.
    • Consume unified-diff file metadata through mizchi/bit_apply without reimplementing diff generation, hunk parsing, patch application, or reversal.

    #Quick Start

    Install a current MoonBit toolchain, then run:

    moon update
moon check --target wasm-gc --deny-warn
moon test --target wasm-gc
moon run cmd/moonchange --target js -- demo

    Audit the committed explicit manifest example:

    moon run cmd/moonchange --target js -- audit \
  --policy examples/policy.mcp \
  --manifest examples/manifest.mcm \
  --format json

    Audit the same workflow from a real Git diff plus review evidence:

    moon run cmd/moonchange --target js -- audit-diff \
  --policy examples/policy.mcp \
  --evidence examples/evidence.mce \
  --diff examples/change.diff

    Explain and lint policy behavior:

    moon run cmd/moonchange --target js -- explain \
  --policy examples/policy.mcp --path src/security/auth.mbt
moon run cmd/moonchange --target js -- lint --policy examples/policy.mcp

    Compare policy versions over a reviewed path inventory:

    moon run cmd/moonchange --target js -- compare \
  --before examples/policy-before.mcp \
  --after examples/policy.mcp \
  --paths examples/paths.txt

    Exit code 0 means passed/clean, 1 means review evidence or lint attention is needed, and 2 means rejected or invalid input.

    All report commands accept --format text|json. JSON documents use explicit schema identifiers such as moonchange.audit.v1; field order is deterministic, but consumers should select fields by name.

    #Policy Format

    MOONCHANGE_POLICY 1
DEFAULT approvals=1 max_total=500 require_owned=yes
OWNER **/* @maintainers
OWNER src/security/** @security,@maintainers
RULE source src/** approvals=1 checks=unit labels=code forbid=delete max_lines=200 release_note=no binary=deny

    Owner lists are alternatives used to satisfy the path quorum. All matching RULE lines contribute obligations. Approval counts take the maximum, line budgets take the minimum, sets are unioned, and boolean restrictions use the strictest result. Use max_total=- or max_lines=- for no limit. A quorum larger than the resolved owner pool is rejected as an impossible policy.

    #Explicit Manifest Format

    MOONCHANGE 1
ID PR-42
ACTOR @alice
APPROVAL @maintainers
CHECK unit passed
LABEL code
RELEASE_NOTE no
CHANGE modify src/main.mbt 8 2 text

    For rename and copy, provide old and new paths. Other operations take one path. Each change ends with additions, deletions, and text or binary.

    #Diff Evidence Format

    audit-diff uses a separate MOONCHANGE_EVIDENCE 1 file containing the same ID, actor, approval, check, label, and release-note fields. File operations and line counts come exclusively from upstream PatchInfo values.

    For callers constructing Evidence directly, duplicate check names are reconciled conservatively: failed dominates pending, which dominates passed. Text parsers reject duplicates so file inputs remain unambiguous.

    #Library

    let policy = @moonchange.parse_policy(policy_text).unwrap()
    let changes = @moonchange.parse_manifest(manifest_text).unwrap()
    let report = @moonchange.evaluate(policy, changes)
    inspect(report.status(), content="Passed")

    pkg.generated.mbti records the complete generated public interface.

    #Verification

    moon fmt --check
moon check --target wasm-gc --deny-warn
moon check --target wasm --deny-warn
moon check --target js --deny-warn
moon check --target native --deny-warn
moon test --target wasm-gc
moon test --target wasm
moon test --target js
moon test --target native

    Native compilation and execution require a C compiler. GitHub Actions performs native checks, tests, a release build, and real CLI flows on Ubuntu.

    #Boundaries

    MoonChange never applies patches, reconstructs hunks, generates diffs, mutates a repository, calls Git, contacts GitHub, or evaluates branch protection rules. The diff adapter cannot identify binary content because upstream PatchInfo does not expose that flag; use an explicit manifest when binary policy matters. See Support, Architecture, and Originality for exact behavior and provenance.

    #License

    MoonChange is MIT licensed. Original implementation: okMambaOut; maintenance contributors are recorded in CONTRIBUTORS.md. See Third-Party Notices and AI Usage.

    #Maintenance quality evidence

    The path matcher uses linear auxiliary state without changing its public API. The suite includes 13,091 exhaustive oracle pairs and maximum-length/depth regressions. See the maintenance report for exact scope, state-slot reductions, reproduction commands and measurement limitations.

    #MoonCakes distribution

    The maintained release is distributed as ZJH-666-ZJH/moonchange@0.2.1:

    moon add ZJH-666-ZJH/moonchange@0.2.1

    Import ZJH-666-ZJH/moonchange in your package manifest (for example with alias moonchange). The repository remains okMambaOut/moonchange; this is an explicitly attributed maintenance distribution, not a claim that the original project was authored by ZJH-666-ZJH. Existing consumers of an older namespace must update their module dependency and package import paths.

    AuditReport

    source
    pub struct AuditReport {
      change_id : String
      status : GateStatus
      total_lines : Int
      decisions : Array[PathDecision]
      findings : Array[Finding]
      plan : ReviewPlan
    } derive(Eq, 
    Debug    )

    AuditReport::change_id

    source
    fn AuditReport::change_id(self : AuditReport) -> String

    AuditReport::decisions

    source
    fn AuditReport::decisions(self : AuditReport) -> Array[PathDecision]

    AuditReport::findings

    source
    fn AuditReport::findings(self : AuditReport) -> Array[Finding]

    AuditReport::has_code

    source
    fn AuditReport::has_code(self : AuditReport, code : String) -> Bool

    AuditReport::plan

    source
    fn AuditReport::plan(self : AuditReport) -> ReviewPlan

    AuditReport::status

    source
    fn AuditReport::status(self : AuditReport) -> GateStatus

    AuditReport::to_json

    source
    fn AuditReport::to_json(self : AuditReport) -> String

    AuditReport::to_text

    source
    fn AuditReport::to_text(self : AuditReport) -> String

    AuditReport::total_lines

    source
    fn AuditReport::total_lines(self : AuditReport) -> Int

    Change

    source
    pub struct Change {
      kind : ChangeKind
      old_path : String?
      new_path : String?
      additions : Int
      deletions : Int
      binary : Bool
    } derive(Eq, 
    Debug    )

    Change::additions

    source
    fn Change::additions(self : Change) -> Int

    Change::changed_lines

    source
    fn Change::changed_lines(self : Change) -> Int

    Change::deletions

    source
    fn Change::deletions(self : Change) -> Int

    Change::is_binary

    source
    fn Change::is_binary(self : Change) -> Bool

    Change::kind

    source
    fn Change::kind(self : Change) -> ChangeKind

    Change::new

    source
    fn Change::new(kind : ChangeKind, old_path : String?, new_path : String?, additions : Int, deletions : Int, binary? : Bool) -> Result[Change, Diagnostic]

    Change::new_path

    source
    fn Change::new_path(self : Change) -> String?

    Change::old_path

    source
    fn Change::old_path(self : Change) -> String?

    Change::policy_path

    source
    fn Change::policy_path(self : Change) -> String

    ChangeKind

    source
    pub(all) enum ChangeKind {
      Add
      Modify
      Delete
      Rename
      Copy
    } derive(Eq, 
    Debug    )

    ChangeKind::parse

    source
    fn ChangeKind::parse(value : String) -> ChangeKind?

    ChangeKind::to_text

    source
    fn ChangeKind::to_text(self : ChangeKind) -> String

    ChangeSet

    source
    pub struct ChangeSet {
      id : String
      changes : Array[Change]
      evidence : Evidence
    } derive(Eq, 
    Debug    )

    ChangeSet::changes

    source
    fn ChangeSet::changes(self : ChangeSet) -> Array[Change]

    ChangeSet::evidence

    source
    fn ChangeSet::evidence(self : ChangeSet) -> Evidence

    ChangeSet::id

    source
    fn ChangeSet::id(self : ChangeSet) -> String

    ChangeSet::new

    source
    fn ChangeSet::new(id : String, changes : Array[Change], evidence : Evidence) -> Result[ChangeSet, Diagnostic]

    ChangeSet::to_text

    source
    fn ChangeSet::to_text(self : ChangeSet) -> String

    CheckResult

    source
    pub struct CheckResult {
      name : String
      state : CheckState
    } derive(Eq, 
    Debug    )

    CheckResult::name

    source
    fn CheckResult::name(self : CheckResult) -> String

    CheckResult::new

    source
    fn CheckResult::new(name : String, state : CheckState) -> CheckResult

    CheckResult::state

    source
    fn CheckResult::state(self : CheckResult) -> CheckState

    CheckState

    source
    pub(all) enum CheckState {
      Passed
      Failed
      Pending
    } derive(Eq, 
    Debug    )

    CheckState::parse

    source
    fn CheckState::parse(value : String) -> CheckState?

    CheckState::to_text

    source
    fn CheckState::to_text(self : CheckState) -> String

    CommandResult

    source
    pub struct CommandResult {
      exit_code : Int
      output : String
    } derive(Eq, 
    Debug    )

    CommandResult::exit_code

    source
    fn CommandResult::exit_code(self : CommandResult) -> Int

    CommandResult::output

    source
    fn CommandResult::output(self : CommandResult) -> String

    Diagnostic

    source
    pub struct Diagnostic {
      code : String
      location : String
      message : String
      expected : String
      actual : String
    } derive(Eq, 
    Debug    )

    A stable, machine-readable policy, manifest, or evaluation failure.

    Diagnostic::actual

    source
    fn Diagnostic::actual(self : Diagnostic) -> String

    Diagnostic::code

    source
    fn Diagnostic::code(self : Diagnostic) -> String

    Diagnostic::expected

    source
    fn Diagnostic::expected(self : Diagnostic) -> String

    Diagnostic::location

    source
    fn Diagnostic::location(self : Diagnostic) -> String

    Diagnostic::message

    source
    fn Diagnostic::message(self : Diagnostic) -> String

    Diagnostic::new

    source
    fn Diagnostic::new(code : String, location : String, message : String, expected : String, actual : String) -> Diagnostic

    Diagnostic::to_text

    source
    fn Diagnostic::to_text(self : Diagnostic) -> String

    Evidence

    source
    pub struct Evidence {
      actor : String
      approvals : Array[String]
      checks : Array[CheckResult]
      labels : Array[String]
      release_note : Bool
    } derive(Eq, 
    Debug    )

    Evidence::actor

    source
    fn Evidence::actor(self : Evidence) -> String

    Evidence::approvals

    source
    fn Evidence::approvals(self : Evidence) -> Array[String]

    Evidence::checks

    source
    fn Evidence::checks(self : Evidence) -> Array[CheckResult]

    Evidence::has_release_note

    source
    fn Evidence::has_release_note(self : Evidence) -> Bool

    Evidence::labels

    source
    fn Evidence::labels(self : Evidence) -> Array[String]

    Evidence::new

    source
    fn Evidence::new(actor : String, approvals : Array[String], checks : Array[CheckResult], labels : Array[String], release_note? : Bool) -> Evidence

    Finding

    source
    pub struct Finding {
      level : FindingLevel
      code : String
      path : String
      message : String
    } derive(Eq, 
    Debug    )

    Finding::code

    source
    fn Finding::code(self : Finding) -> String

    Finding::level

    source
    fn Finding::level(self : Finding) -> FindingLevel

    Finding::message

    source
    fn Finding::message(self : Finding) -> String

    Finding::new

    source
    fn Finding::new(level : FindingLevel, code : String, path : String, message : String) -> Finding

    Finding::path

    source
    fn Finding::path(self : Finding) -> String

    Finding::to_json

    source
    fn Finding::to_json(self : Finding) -> String

    Finding::to_text

    source
    fn Finding::to_text(self : Finding) -> String

    FindingLevel

    source
    pub(all) enum FindingLevel {
      Attention
      Blocking
    } derive(Eq, 
    Debug    )

    FindingLevel::to_text

    source
    fn FindingLevel::to_text(self : FindingLevel) -> String

    GateStatus

    source
    pub(all) enum GateStatus {
      Passed
      Review
      Rejected
    } derive(Eq, 
    Debug    )

    GateStatus::to_text

    source
    fn GateStatus::to_text(self : GateStatus) -> String

    GovernanceRule

    source
    pub struct GovernanceRule {
      name : String
      pattern : PathGlob
      approvals : Int
      checks : Array[String]
      labels : Array[String]
      forbidden : Array[ChangeKind]
      max_lines : Int?
      release_note : Bool
      allow_binary : Bool
    } derive(Eq, 
    Debug    )

    GovernanceRule::allows_binary

    source
    fn GovernanceRule::allows_binary(self : GovernanceRule) -> Bool

    GovernanceRule::approvals

    source
    fn GovernanceRule::approvals(self : GovernanceRule) -> Int

    GovernanceRule::checks

    source
    fn GovernanceRule::checks(self : GovernanceRule) -> Array[String]

    GovernanceRule::forbidden

    source
    fn GovernanceRule::forbidden(self : GovernanceRule) -> Array[ChangeKind]

    GovernanceRule::labels

    source
    fn GovernanceRule::labels(self : GovernanceRule) -> Array[String]

    GovernanceRule::max_lines

    source
    fn GovernanceRule::max_lines(self : GovernanceRule) -> Int?

    GovernanceRule::name

    source
    fn GovernanceRule::name(self : GovernanceRule) -> String

    GovernanceRule::new

    source
    fn GovernanceRule::new(name : String, pattern : PathGlob, approvals? : Int, checks? : Array[String], labels? : Array[String], forbidden? : Array[ChangeKind], max_lines? : Int?, release_note? : Bool, allow_binary? : Bool) -> Result[GovernanceRule, Diagnostic]

    GovernanceRule::pattern

    source
    fn GovernanceRule::pattern(self : GovernanceRule) -> PathGlob

    GovernanceRule::requires_release_note

    source
    fn GovernanceRule::requires_release_note(self : GovernanceRule) -> Bool

    LintIssue

    source
    pub struct LintIssue {
      level : LintLevel
      code : String
      subject : String
      message : String
    } derive(Eq, 
    Debug    )

    LintIssue::code

    source
    fn LintIssue::code(self : LintIssue) -> String

    LintIssue::level

    source
    fn LintIssue::level(self : LintIssue) -> LintLevel

    LintIssue::message

    source
    fn LintIssue::message(self : LintIssue) -> String

    LintIssue::subject

    source
    fn LintIssue::subject(self : LintIssue) -> String

    LintIssue::to_json

    source
    fn LintIssue::to_json(self : LintIssue) -> String

    LintIssue::to_text

    source
    fn LintIssue::to_text(self : LintIssue) -> String

    LintLevel

    source
    pub(all) enum LintLevel {
      LintInfo
      LintWarning
      LintError
    } derive(Eq, 
    Debug    )

    LintLevel::to_text

    source
    fn LintLevel::to_text(self : LintLevel) -> String

    LintReport

    source
    pub struct LintReport {
      issues : Array[LintIssue]
    } derive(Eq, 
    Debug    )

    LintReport::has_code

    source
    fn LintReport::has_code(self : LintReport, code : String) -> Bool

    LintReport::has_errors

    source
    fn LintReport::has_errors(self : LintReport) -> Bool

    LintReport::is_clean

    source
    fn LintReport::is_clean(self : LintReport) -> Bool

    LintReport::issues

    source
    fn LintReport::issues(self : LintReport) -> Array[LintIssue]

    LintReport::to_json

    source
    fn LintReport::to_json(self : LintReport) -> String

    LintReport::to_text

    source
    fn LintReport::to_text(self : LintReport) -> String

    OwnerRule

    source
    pub struct OwnerRule {
      pattern : PathGlob
      owners : Array[String]
    } derive(Eq, 
    Debug    )

    OwnerRule::new

    source
    fn OwnerRule::new(pattern : PathGlob, owners : Array[String]) -> Result[OwnerRule, Diagnostic]

    OwnerRule::owners

    source
    fn OwnerRule::owners(self : OwnerRule) -> Array[String]

    OwnerRule::pattern

    source
    fn OwnerRule::pattern(self : OwnerRule) -> PathGlob

    PathDecision

    source
    pub struct PathDecision {
      path : String
      owners : Array[String]
      owner_pattern : String?
      matched_rules : Array[String]
      approvals : Int
      checks : Array[String]
      labels : Array[String]
      forbidden : Array[ChangeKind]
      max_lines : Int?
      release_note : Bool
      allow_binary : Bool
    } derive(Eq, 
    Debug    )

    PathDecision::allows_binary

    source
    fn PathDecision::allows_binary(self : PathDecision) -> Bool

    PathDecision::approvals

    source
    fn PathDecision::approvals(self : PathDecision) -> Int

    PathDecision::checks

    source
    fn PathDecision::checks(self : PathDecision) -> Array[String]

    PathDecision::forbidden

    source
    fn PathDecision::forbidden(self : PathDecision) -> Array[ChangeKind]

    PathDecision::labels

    source
    fn PathDecision::labels(self : PathDecision) -> Array[String]

    PathDecision::matched_rules

    source
    fn PathDecision::matched_rules(self : PathDecision) -> Array[String]

    PathDecision::max_lines

    source
    fn PathDecision::max_lines(self : PathDecision) -> Int?

    PathDecision::owner_pattern

    source
    fn PathDecision::owner_pattern(self : PathDecision) -> String?

    PathDecision::owners

    source
    fn PathDecision::owners(self : PathDecision) -> Array[String]

    PathDecision::path

    source
    fn PathDecision::path(self : PathDecision) -> String

    PathDecision::requires_release_note

    source
    fn PathDecision::requires_release_note(self : PathDecision) -> Bool

    PathDecision::to_explain_json

    source
    fn PathDecision::to_explain_json(self : PathDecision) -> String

    PathDecision::to_json

    source
    fn PathDecision::to_json(self : PathDecision) -> String

    PathDecision::to_text

    source
    fn PathDecision::to_text(self : PathDecision) -> String

    PathGlob

    source
    pub struct PathGlob {
      source : String
      segments : Array[String]
      specificity : Int
    } derive(Eq, 
    Debug    )

    PathGlob::compile

    source
    fn PathGlob::compile(source : String) -> Result[PathGlob, Diagnostic]

    PathGlob::matches

    source
    fn PathGlob::matches(self : PathGlob, path : String) -> Bool

    PathGlob::source

    source
    fn PathGlob::source(self : PathGlob) -> String

    PathGlob::specificity

    source
    fn PathGlob::specificity(self : PathGlob) -> Int

    PathPolicyDelta

    source
    pub struct PathPolicyDelta {
      path : String
      before : PathDecision
      after : PathDecision
      owners : StringDelta
      rules : StringDelta
      checks : StringDelta
      labels : StringDelta
      forbidden : StringDelta
    } derive(Eq, 
    Debug    )

    PathPolicyDelta::after

    source

    PathPolicyDelta::before

    source

    PathPolicyDelta::changed

    source
    fn PathPolicyDelta::changed(self : PathPolicyDelta) -> Bool

    PathPolicyDelta::checks

    source

    PathPolicyDelta::forbidden

    source

    PathPolicyDelta::labels

    source

    PathPolicyDelta::owners

    source

    PathPolicyDelta::path

    source
    fn PathPolicyDelta::path(self : PathPolicyDelta) -> String

    PathPolicyDelta::rules

    source

    PathPolicyDelta::to_json

    source
    fn PathPolicyDelta::to_json(self : PathPolicyDelta) -> String

    Policy

    source
    pub struct Policy {
      default_approvals : Int
      max_total_lines : Int?
      require_owned : Bool
      owner_rules : Array[OwnerRule]
      rules : Array[GovernanceRule]
    } derive(Eq, 
    Debug    )

    Policy::default_approvals

    source
    fn Policy::default_approvals(self : Policy) -> Int

    Policy::explain

    source
    fn Policy::explain(self : Policy, path : String) -> Result[PathDecision, Diagnostic]

    Policy::max_total_lines

    source
    fn Policy::max_total_lines(self : Policy) -> Int?

    Policy::new

    source
    fn Policy::new(default_approvals? : Int, max_total_lines? : Int?, require_owned? : Bool, owner_rules? : Array[OwnerRule], rules? : Array[GovernanceRule]) -> Result[Policy, Diagnostic]

    Policy::owner_rules

    source
    fn Policy::owner_rules(self : Policy) -> Array[OwnerRule]

    Policy::requires_owned_paths

    source
    fn Policy::requires_owned_paths(self : Policy) -> Bool

    Policy::rules

    source
    fn Policy::rules(self : Policy) -> Array[GovernanceRule]

    Policy::to_text

    source
    fn Policy::to_text(self : Policy) -> String

    PolicyComparison

    source
    pub struct PolicyComparison {
      paths : Array[PathPolicyDelta]
    } derive(Eq, 
    Debug    )

    PolicyComparison::changed_count

    source
    fn PolicyComparison::changed_count(self : PolicyComparison) -> Int

    PolicyComparison::paths

    source

    PolicyComparison::to_json

    source
    fn PolicyComparison::to_json(self : PolicyComparison) -> String

    PolicyComparison::to_text

    source
    fn PolicyComparison::to_text(self : PolicyComparison) -> String

    ReviewEvidence

    source
    pub struct ReviewEvidence {
      id : String
      evidence : Evidence
    } derive(Eq, 
    Debug    )

    ReviewEvidence::evidence

    source
    fn ReviewEvidence::evidence(self : ReviewEvidence) -> Evidence

    ReviewEvidence::id

    source
    fn ReviewEvidence::id(self : ReviewEvidence) -> String

    ReviewEvidence::to_text

    source
    fn ReviewEvidence::to_text(self : ReviewEvidence) -> String

    ReviewPlan

    source
    pub struct ReviewPlan {
      required_owners : Array[String]
      approved_owners : Array[String]
      unapproved_owners : Array[String]
      required_checks : Array[String]
      passed_checks : Array[String]
      unresolved_checks : Array[String]
      required_labels : Array[String]
      present_labels : Array[String]
      missing_labels : Array[String]
      touched_rules : Array[String]
      maximum_path_approvals : Int
      release_note_required : Bool
      release_note_present : Bool
    } derive(Eq, 
    Debug    )

    ReviewPlan::approved_owners

    source
    fn ReviewPlan::approved_owners(self : ReviewPlan) -> Array[String]

    ReviewPlan::has_release_note

    source
    fn ReviewPlan::has_release_note(self : ReviewPlan) -> Bool

    ReviewPlan::maximum_path_approvals

    source
    fn ReviewPlan::maximum_path_approvals(self : ReviewPlan) -> Int

    ReviewPlan::missing_labels

    source
    fn ReviewPlan::missing_labels(self : ReviewPlan) -> Array[String]

    ReviewPlan::passed_checks

    source
    fn ReviewPlan::passed_checks(self : ReviewPlan) -> Array[String]

    ReviewPlan::present_labels

    source
    fn ReviewPlan::present_labels(self : ReviewPlan) -> Array[String]

    ReviewPlan::required_checks

    source
    fn ReviewPlan::required_checks(self : ReviewPlan) -> Array[String]

    ReviewPlan::required_labels

    source
    fn ReviewPlan::required_labels(self : ReviewPlan) -> Array[String]

    ReviewPlan::required_owners

    source
    fn ReviewPlan::required_owners(self : ReviewPlan) -> Array[String]

    ReviewPlan::requires_release_note

    source
    fn ReviewPlan::requires_release_note(self : ReviewPlan) -> Bool

    ReviewPlan::to_json

    source
    fn ReviewPlan::to_json(self : ReviewPlan) -> String

    ReviewPlan::to_text

    source
    fn ReviewPlan::to_text(self : ReviewPlan) -> String

    ReviewPlan::touched_rules

    source
    fn ReviewPlan::touched_rules(self : ReviewPlan) -> Array[String]

    ReviewPlan::unapproved_owners

    source
    fn ReviewPlan::unapproved_owners(self : ReviewPlan) -> Array[String]

    ReviewPlan::unresolved_checks

    source
    fn ReviewPlan::unresolved_checks(self : ReviewPlan) -> Array[String]

    StringDelta

    source
    pub struct StringDelta {
      added : Array[String]
      removed : Array[String]
    } derive(Eq, 
    Debug    )

    StringDelta::added

    source
    fn StringDelta::added(self : StringDelta) -> Array[String]

    StringDelta::changed

    source
    fn StringDelta::changed(self : StringDelta) -> Bool

    StringDelta::removed

    source
    fn StringDelta::removed(self : StringDelta) -> Array[String]

    StringDelta::to_json

    source
    fn StringDelta::to_json(self : StringDelta) -> String

    change_set_from_unified_diff

    source
    fn change_set_from_unified_diff(id : String, evidence : Evidence, source : String) -> Result[ChangeSet, Diagnostic]

    changes_from_unified_diff

    source
    fn changes_from_unified_diff(source : String) -> Result[Array[Change], Diagnostic]

    compare_policies

    source
    fn compare_policies(before : Policy, after : Policy, paths : Array[String]) -> Result[PolicyComparison, Diagnostic]

    evaluate

    source
    fn evaluate(policy : Policy, changes : ChangeSet) -> AuditReport

    execute

    source
    fn execute(args : Array[String]) -> CommandResult

    lint_policy

    source
    fn lint_policy(policy : Policy) -> LintReport

    parse_manifest

    source
    fn parse_manifest(source : String) -> Result[ChangeSet, Diagnostic]

    parse_policy

    source
    fn parse_policy(source : String) -> Result[Policy, Diagnostic]

    parse_review_evidence

    source
    fn parse_review_evidence(source : String) -> Result[ReviewEvidence, Diagnostic]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io