🥮 mooncakes.io

cakecheck

MoonBit package readiness auditor for Mooncakes releases

moonbit
mooncakes
audit
ci
quality
moon add ZBZ-ai-nb/cakecheck@0.1.0
Download zip
Author
Version
0.1.0
License
MIT
Repository
Last updated
9 hours ago
Downloads
2
README

#CakeCheck

CakeCheck 是一个用 MoonBit 实现的 MoonBit/Mooncakes 包发布前质量审计库。它不是通用文本检查脚本，而是把 MoonBit 开源包验收中最容易遗漏的工程项做成可复用的数据模型、规则集、评分器和报告导出器。

#解决的问题

MoonBit 包作者在发布前通常需要反复确认 moon.mod、README、CI、许可证、提交记录、Mooncakes 发布状态是否一致。CakeCheck 接收这些文件文本和仓库状态，输出结构化检查结果、ready 分数、门禁结果、修复计划、证据矩阵、质量矩阵、发布计划、Markdown 报告和 JSON 摘要，适合接入 CI、发布脚本、课程作业检查器或开源项目维护工具。

#适用场景

  • MoonBit 库作者发布 Mooncakes 包前的自检。
  • 黑客松、课程项目、开源活动的验收辅助。
  • CI 中生成发布质量报告。
  • 维护多个 MoonBit 包时统一检查 README、CI 和许可证规范。
  • WebAssembly 工具中对项目文本做轻量审计。

#安装

发布后可在 MoonBit 项目中添加：

moon add ZBZ-ai-nb/cakecheck@0.1.0

当前 Mooncakes 包名：

ZBZ-ai-nb/cakecheck

GitHub 仓库、README、申报书和 moon.mod 中的包名保持一致。

#最小使用示例

let input = @audit.sample_good_input()
let report = @audit.audit_project(input)
println(report.summary())
println(report.to_markdown())

完整示例：

moon run examples/basic

CLI smoke 入口：

moon run cmd/main

#API 与核心功能

pub fn audit_project(input : AuditInput) -> AuditReport
pub fn parse_manifest(text : String) -> ManifestInfo
pub fn sample_good_input() -> AuditInput
pub fn sample_risky_input() -> AuditInput
pub fn AuditReport::summary(self : AuditReport) -> String
pub fn AuditReport::to_markdown(self : AuditReport) -> String
pub fn AuditReport::to_json(self : AuditReport) -> String
pub fn AuditReport::has_errors(self : AuditReport) -> Bool
pub fn AuditReport::is_ready(self : AuditReport) -> Bool
pub fn AuditReport::gate(self : AuditReport, profile : AuditProfile) -> GateResult
pub fn AuditReport::remediation_plan(self : AuditReport, limit : Int) -> String
pub fn diff_reports(before : AuditReport, after : AuditReport) -> AuditDiff
pub fn analyze_readme(readme : String) -> ReadmeMetrics
pub fn analyze_workflow(text : String) -> WorkflowInfo
pub fn analyze_license(text : String) -> LicenseFacts
pub fn parse_semver(value : String) -> SemVerInfo
pub fn analyze_namespace(raw : String, repository : String) -> NamespaceInfo
pub fn analyze_api_compatibility(before : String, after : String) -> ApiCompatibility
pub fn api_snapshot_declarations(snapshot : String) -> Array[String]
pub fn build_acceptance_evidence(input : AuditInput) -> EvidenceMatrix
pub fn build_release_plan(input : AuditInput) -> ReleasePlan
pub fn build_quality_matrix(input : AuditInput) -> QualityMatrix
pub fn review_acceptance(input : AuditInput) -> AcceptanceReview

核心检查包括：

  • moon.mod 必填字段、包名格式、semver 版本、GitHub 仓库 URL、OSI 许可证字段。
  • README 是否包含安装、用法、示例、验收命令、许可证、包名一致性；常见中英文标题都可识别。
  • GitHub Actions 是否安装 MoonBit 并运行 moon check、moon build、moon test、moon run。
  • LICENSE 是否可被轻量识别。
  • 仓库是否公开、提交数量是否足够、CHANGELOG 是否存在。
  • Mooncakes 发布状态和占位符风险。
  • 不同 profile 下的发布门禁结果。
  • README 结构指标、CI 命令覆盖、许可证事实、semver 版本比较和包命名空间一致性。
  • 验收证据矩阵、Mooncakes 发布计划、质量矩阵和最终验收评审摘要。
  • 公共 API 快照兼容性分析，识别新增/删除声明并给出 SemVer bump 建议。

#支持范围

  • 以文本形式审计 MoonBit 项目配置和文档。
  • 适合 CI、教学验收、发布前检查、Mooncakes 包维护场景。
  • 输出结构化 AuditReport，可导出 Markdown 和 JSON。
  • 支持 Quick、Release、Hackathon 三种门禁 profile。
  • 支持生成修复建议计划，优先列出错误和警告。
  • 支持比较两次审计结果，展示 ready 分数变化、已修复项和新增问题。
  • 支持生成 Acceptance Evidence、Release Plan、Quality Matrix 和 Acceptance Review。
  • 不依赖第三方库，不读取外部文件，不访问网络。
  • 不提取 README 代码块或建立第三方来源证明，专注于 Mooncakes 发布契约和 API 版本兼容性。

#暂不支持范围

  • 不直接替代 moon check、moon build、moon test。
  • 不登录 GitHub 或 Mooncakes，也不执行发布。
  • 不完整解析 YAML、Markdown AST 或 SPDX 全量许可证库。
  • 不自动读取磁盘文件；上层工具负责把文件内容传入 AuditInput。

#本地运行与验收命令

moon fmt --check
moon check
moon check --deny-warn
moon build
moon test
moon test --deny-warn
moon run examples/basic
moon run cmd/main
moon info
moon publish --dry-run

测试覆盖正常项目、风险项目、moon.mod 解析、中英文 README 覆盖项、CI 命令、评分、Markdown 与 JSON 导出、profile 门禁、修复计划、审计 diff、semver、命名空间、API 快照兼容性、证据矩阵、发布计划、质量矩阵和验收评审。

当前 MoonBit 源码规模：

4,929 non-empty non-comment MoonBit code lines
5,638 total .mbt lines

#项目资料

  • HACKATHON_APPLICATION.md：8 月黑客松一页 Markdown 项目申报书。
  • TASK_REPORT.md：项目任务报告书。
  • docs/API.md：公开 API 说明。
  • docs/DESIGN.md：架构和设计说明。
  • docs/DIFFERENTIATION.md：相邻项目调研和选题差异化边界。
  • docs/TESTING.md：测试记录和本地验证命令。
  • docs/ACCEPTANCE_SELF_REVIEW.md：验收自查证据。
  • docs/PUSH_RELEASE_CHECKLIST.md：推送和 Mooncakes 发布清单。
  • docs/DEVELOPMENT_RECORD.md：开发过程、工单和设计决策记录。
  • docs/OPEN_SOURCE_COMPLIANCE.md：开源许可证、来源和生成文件合规记录。
  • CONTRIBUTING.md：贡献和本地开发流程。
  • SECURITY.md：安全边界和问题反馈说明。
  • pkg.generated.mbti：moon info 生成的公开 API 快照。

#Mooncakes 发布

moon.mod 发布字段：

name = "ZBZ-ai-nb/cakecheck"
version = "0.1.0"
readme = "README.md"
repository = "https://github.com/ZBZ-ai-nb/cakecheck.git"
license = "MIT"
description = "MoonBit package readiness auditor for Mooncakes releases"

发布流程：

moon login
moon publish --dry-run
moon publish

发布后检查：

https://mooncakes.io/docs/ZBZ-ai-nb/cakecheck
https://mooncakes.io/api/v0/manifest/ZBZ-ai-nb/cakecheck

#开源许可证与参考

本项目使用 MIT 许可证。核心实现为原创 MoonBit 代码，不移植第三方源码，不包含来源不明素材。许可证、来源和生成文件说明见 docs/OPEN_SOURCE_COMPLIANCE.md。项目规则参考 MoonBit 官方工具链文档和 Mooncakes 包发布要求。

#
AcceptanceLevel

source
pub(all) enum AcceptanceLevel {
  AcceptanceReady
  AcceptanceNearlyReady
  AcceptanceNeedsWork
  AcceptanceBlocked
} derive(Eq, 
Debug)

#
AcceptanceReview

source
pub(all) struct AcceptanceReview {
  report : AuditReport
  evidence : EvidenceMatrix
  quality : QualityMatrix
  release_plan : ReleasePlan
  level : AcceptanceLevel
  decision : String
} derive(Eq, 
Debug)

#
AcceptanceReview::blocking_reasons

source
fn AcceptanceReview::blocking_reasons(self : AcceptanceReview) -> Array[String]

#
AcceptanceReview::is_likely_to_pass

source
fn AcceptanceReview::is_likely_to_pass(self : AcceptanceReview) -> Bool

#
AcceptanceReview::is_submission_risky

source
fn AcceptanceReview::is_submission_risky(self : AcceptanceReview) -> Bool

#
AcceptanceReview::level_name

source
fn AcceptanceReview::level_name(self : AcceptanceReview) -> String

#
AcceptanceReview::next_actions

source
fn AcceptanceReview::next_actions(self : AcceptanceReview) -> Array[String]

#
AcceptanceReview::positive_signals

source
fn AcceptanceReview::positive_signals(self : AcceptanceReview) -> Array[String]

#
AcceptanceReview::summary

source
fn AcceptanceReview::summary(self : AcceptanceReview) -> String

#
AcceptanceReview::to_markdown

source
fn AcceptanceReview::to_markdown(self : AcceptanceReview) -> String

#
ApiCompatibility

source
pub(all) struct ApiCompatibility {
  before_count : Int
  after_count : Int
  added : Array[String]
  removed : Array[String]
  required_bump : VersionBump
} derive(Eq, 
Debug)

#
ApiCompatibility::has_changes

source
fn ApiCompatibility::has_changes(self : ApiCompatibility) -> Bool

#
ApiCompatibility::is_compatible

source
fn ApiCompatibility::is_compatible(self : ApiCompatibility) -> Bool

#
ApiCompatibility::summary

source
fn ApiCompatibility::summary(self : ApiCompatibility) -> String

#
ApiCompatibility::to_markdown

source
fn ApiCompatibility::to_markdown(self : ApiCompatibility) -> String

#
AuditCheck

source
pub(all) struct AuditCheck {
  category : Category
  severity : Severity
  code : String
  message : String
  hint : String
} derive(Eq, 
Debug)

#
AuditDiff

source
pub(all) struct AuditDiff {
  before_readiness : Int
  after_readiness : Int
  readiness_delta : Int
  fixed_codes : Array[String]
  new_problem_codes : Array[String]
} derive(Eq, 
Debug)

#
AuditDiff::summary

source
fn AuditDiff::summary(self : AuditDiff) -> String

#
AuditDiff::to_markdown

source
fn AuditDiff::to_markdown(self : AuditDiff) -> String

#
AuditInput

source
pub(all) struct AuditInput {
  moon_mod : String
  readme : String
  ci : String
  license_text : String
  changelog : String
  repository_public : Bool
  commit_count : Int
  package_published : Bool
} derive(Eq, 
Debug)

#
AuditProfile

source
pub(all) enum AuditProfile {
  Quick
  Release
  Hackathon
} derive(Eq, 
Debug)

#
AuditReport

source
pub(all) struct AuditReport {
  package_name : String
  version : String
  checks : Array[AuditCheck]
  score : Score
} derive(Eq, 
Debug)

#
AuditReport::first_problem

source
fn AuditReport::first_problem(self : AuditReport) -> AuditCheck?

#
AuditReport::gate

source
fn AuditReport::gate(self : AuditReport, profile : AuditProfile) -> GateResult

#
AuditReport::has_errors

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

#
AuditReport::is_ready

source
fn AuditReport::is_ready(self : AuditReport) -> Bool

#
AuditReport::pass_count

source
fn AuditReport::pass_count(self : AuditReport, category : Category) -> Int

#
AuditReport::problem_count

source
fn AuditReport::problem_count(self : AuditReport, category : Category) -> Int

#
AuditReport::remediation_plan

source
fn AuditReport::remediation_plan(self : AuditReport, limit : Int) -> String

#
AuditReport::summary

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

#
AuditReport::to_json

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

#
AuditReport::to_markdown

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

#
Category

source
pub(all) enum Category {
  Manifest
  Readme
  CI
  License
  Release
  Repository
} derive(Eq, 
Debug)

#
EvidenceItem

source
pub(all) struct EvidenceItem {
  code : String
  label : String
  present : Bool
  source : String
} derive(Eq, 
Debug)

#
EvidenceItem::markdown_row

source
fn EvidenceItem::markdown_row(self : EvidenceItem) -> String

#
EvidenceItem::status_text

source
fn EvidenceItem::status_text(self : EvidenceItem) -> String

#
EvidenceMatrix

source
pub(all) struct EvidenceMatrix {
  items : Array[EvidenceItem]
  present_count : Int
  missing_count : Int
} derive(Eq, 
Debug)

#
EvidenceMatrix::acceptance_label

source
fn EvidenceMatrix::acceptance_label(self : EvidenceMatrix) -> String

#
EvidenceMatrix::coverage_percent

source
fn EvidenceMatrix::coverage_percent(self : EvidenceMatrix) -> Int

#
EvidenceMatrix::has

source
fn EvidenceMatrix::has(self : EvidenceMatrix, code : String) -> Bool

#
EvidenceMatrix::is_complete

source
fn EvidenceMatrix::is_complete(self : EvidenceMatrix) -> Bool

#
EvidenceMatrix::missing_codes

source
fn EvidenceMatrix::missing_codes(self : EvidenceMatrix) -> Array[String]

#
EvidenceMatrix::missing_items

source
fn EvidenceMatrix::missing_items(self : EvidenceMatrix) -> Array[EvidenceItem]

#
EvidenceMatrix::missing_label_text

source
fn EvidenceMatrix::missing_label_text(self : EvidenceMatrix) -> String

#
EvidenceMatrix::present_items

source
fn EvidenceMatrix::present_items(self : EvidenceMatrix) -> Array[EvidenceItem]

#
EvidenceMatrix::summary

source
fn EvidenceMatrix::summary(self : EvidenceMatrix) -> String

#
EvidenceMatrix::to_json

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

#
EvidenceMatrix::to_markdown

source
fn EvidenceMatrix::to_markdown(self : EvidenceMatrix) -> String

#
GateResult

source
pub(all) struct GateResult {
  profile : AuditProfile
  passed : Bool
  message : String
  required_codes : Array[String]
} derive(Eq, 
Debug)

#
GateResult::summary

source
fn GateResult::summary(self : GateResult) -> String

#
LicenseFacts

source
pub(all) struct LicenseFacts {
  family : LicenseFamily
  spdx_id : String
  osi_approved : Bool
  has_copyright : Bool
  has_permission_grant : Bool
  has_warranty_disclaimer : Bool
  has_patent_grant : Bool
} derive(Eq, 
Debug)

#
LicenseFacts::completeness_score

source
fn LicenseFacts::completeness_score(self : LicenseFacts) -> Int

#
LicenseFacts::is_publishable

source
fn LicenseFacts::is_publishable(self : LicenseFacts) -> Bool

#
LicenseFacts::summary

source
fn LicenseFacts::summary(self : LicenseFacts) -> String

#
LicenseFacts::to_markdown

source
fn LicenseFacts::to_markdown(self : LicenseFacts) -> String

#
LicenseFamily

source
pub(all) enum LicenseFamily {
  MIT
  Apache2
  BSD2
  BSD3
  MPL2
  UnknownLicense
} derive(Eq, 
Debug)

#
ManifestField

source
pub(all) struct ManifestField {
  key : String
  value : String
  line : Int
} derive(Eq, 
Debug)

#
ManifestInfo

source
pub(all) struct ManifestInfo {
  fields : Array[ManifestField]
  duplicates : Array[String]
  malformed_lines : Array[Int]
} derive(Eq, 
Debug)

#
ManifestInfo::get

source
fn ManifestInfo::get(self : ManifestInfo, key : String) -> String?

#
ManifestInfo::has

source
fn ManifestInfo::has(self : ManifestInfo, key : String) -> Bool

#
ManifestInfo::package_name

source
fn ManifestInfo::package_name(self : ManifestInfo) -> String

#
ManifestInfo::version

source
fn ManifestInfo::version(self : ManifestInfo) -> String

#
NamespaceInfo

source
pub(all) struct NamespaceInfo {
  raw : String
  owner : String
  package_name : String
  valid : Bool
  owner_matches_github : Bool
  package_matches_repo : Bool
} derive(Eq, 
Debug)

#
NamespaceInfo::canonical_name

source
fn NamespaceInfo::canonical_name(self : NamespaceInfo) -> String

#
NamespaceInfo::github_url

source
fn NamespaceInfo::github_url(self : NamespaceInfo) -> String

#
NamespaceInfo::is_publishable

source
fn NamespaceInfo::is_publishable(self : NamespaceInfo) -> Bool

#
NamespaceInfo::mooncakes_url

source
fn NamespaceInfo::mooncakes_url(self : NamespaceInfo) -> String

#
NamespaceInfo::recommendation

source
fn NamespaceInfo::recommendation(self : NamespaceInfo) -> String

#
NamespaceInfo::repository_git_url

source
fn NamespaceInfo::repository_git_url(self : NamespaceInfo) -> String

#
NamespaceInfo::risk_level

source
fn NamespaceInfo::risk_level(self : NamespaceInfo) -> String

#
NamespaceInfo::summary

source
fn NamespaceInfo::summary(self : NamespaceInfo) -> String

#
NamespaceInfo::to_markdown

source
fn NamespaceInfo::to_markdown(self : NamespaceInfo) -> String

#
QualityAxis

source
pub(all) struct QualityAxis {
  name : String
  score : Int
  weight : Int
  note : String
} derive(Eq, 
Debug)

#
QualityAxis::markdown_row

source
fn QualityAxis::markdown_row(self : QualityAxis) -> String

#
QualityAxis::max_points

source
fn QualityAxis::max_points(self : QualityAxis) -> Int

#
QualityAxis::rating

source
fn QualityAxis::rating(self : QualityAxis) -> String

#
QualityAxis::weighted_points

source
fn QualityAxis::weighted_points(self : QualityAxis) -> Int

#
QualityMatrix

source
pub(all) struct QualityMatrix {
  axes : Array[QualityAxis]
  weighted_score : Int
  max_score : Int
  normalized_score : Int
} derive(Eq, 
Debug)

#
QualityMatrix::grade

source
fn QualityMatrix::grade(self : QualityMatrix) -> String

#
QualityMatrix::improvement_notes

source
fn QualityMatrix::improvement_notes(self : QualityMatrix) -> Array[String]

#
QualityMatrix::is_competitive

source
fn QualityMatrix::is_competitive(self : QualityMatrix) -> Bool

#
QualityMatrix::lowest_axis_name

source
fn QualityMatrix::lowest_axis_name(self : QualityMatrix) -> String

#
QualityMatrix::lowest_score

source
fn QualityMatrix::lowest_score(self : QualityMatrix) -> Int

#
QualityMatrix::summary

source
fn QualityMatrix::summary(self : QualityMatrix) -> String

#
QualityMatrix::to_markdown

source
fn QualityMatrix::to_markdown(self : QualityMatrix) -> String

#
ReadmeMetrics

source
pub(all) struct ReadmeMetrics {
  line_count : Int
  heading_count : Int
  code_block_count : Int
  command_count : Int
  link_count : Int
  bullet_count : Int
  has_installation : Bool
  has_usage : Bool
  has_example : Bool
  has_validation : Bool
  has_license : Bool
  has_support_scope : Bool
  has_unsupported_scope : Bool
  sections : Array[SectionInfo]
} derive(Eq, 
Debug)

#
ReadmeMetrics::coverage_score

source
fn ReadmeMetrics::coverage_score(self : ReadmeMetrics) -> Int

#
ReadmeMetrics::is_complete

source
fn ReadmeMetrics::is_complete(self : ReadmeMetrics) -> Bool

#
ReadmeMetrics::missing_topics

source
fn ReadmeMetrics::missing_topics(self : ReadmeMetrics) -> Array[String]

#
ReadmeMetrics::summary

source
fn ReadmeMetrics::summary(self : ReadmeMetrics) -> String

#
ReadmeMetrics::to_markdown

source
fn ReadmeMetrics::to_markdown(self : ReadmeMetrics) -> String

#
ReleasePlan

source
pub(all) struct ReleasePlan {
  package_name : String
  version : String
  steps : Array[ReleaseStep]
  blockers : Array[String]
} derive(Eq, 
Debug)

#
ReleasePlan::command_script

source
fn ReleasePlan::command_script(self : ReleasePlan) -> String

#
ReleasePlan::commands

source
fn ReleasePlan::commands(self : ReleasePlan) -> Array[String]

#
ReleasePlan::first_blocker

source
fn ReleasePlan::first_blocker(self : ReleasePlan) -> String

#
ReleasePlan::is_blocked

source
fn ReleasePlan::is_blocked(self : ReleasePlan) -> Bool

#
ReleasePlan::optional_steps

source
fn ReleasePlan::optional_steps(self : ReleasePlan) -> Array[ReleaseStep]

#
ReleasePlan::publish_steps

source
fn ReleasePlan::publish_steps(self : ReleasePlan) -> Array[ReleaseStep]

#
ReleasePlan::required_steps

source
fn ReleasePlan::required_steps(self : ReleasePlan) -> Array[ReleaseStep]

#
ReleasePlan::summary

source
fn ReleasePlan::summary(self : ReleasePlan) -> String

#
ReleasePlan::to_markdown

source
fn ReleasePlan::to_markdown(self : ReleasePlan) -> String

#
ReleasePlan::validation_steps

source
fn ReleasePlan::validation_steps(self : ReleasePlan) -> Array[ReleaseStep]

#
ReleaseStep

source
pub(all) struct ReleaseStep {
  index : Int
  command : String
  required : Bool
  description : String
} derive(Eq, 
Debug)

#
ReleaseStep::is_publish

source
fn ReleaseStep::is_publish(self : ReleaseStep) -> Bool

#
ReleaseStep::is_validation

source
fn ReleaseStep::is_validation(self : ReleaseStep) -> Bool

#
ReleaseStep::label

source
fn ReleaseStep::label(self : ReleaseStep) -> String

#
ReleaseStep::markdown_row

source
fn ReleaseStep::markdown_row(self : ReleaseStep) -> String

#
Score

source
pub(all) struct Score {
  pass_count : Int
  info_count : Int
  warning_count : Int
  error_count : Int
  total : Int
  readiness : Int
} derive(Eq, 
Debug)

#
SectionInfo

source
pub(all) struct SectionInfo {
  title : String
  level : Int
  line : Int
  body_lines : Int
} derive(Eq, 
Debug)

#
SemVerInfo

source
pub(all) struct SemVerInfo {
  valid : Bool
  major : Int
  minor : Int
  patch : Int
  pre_release : String?
  build_metadata : String?
} derive(Eq, 
Debug)

#
SemVerInfo::acceptance_note

source
fn SemVerInfo::acceptance_note(self : SemVerInfo) -> String

#
SemVerInfo::compare

source
fn SemVerInfo::compare(self : SemVerInfo, other : SemVerInfo) -> Int

#
SemVerInfo::core

source
fn SemVerInfo::core(self : SemVerInfo) -> String

#
SemVerInfo::format

source
fn SemVerInfo::format(self : SemVerInfo) -> String

#
SemVerInfo::has_build_metadata

source
fn SemVerInfo::has_build_metadata(self : SemVerInfo) -> Bool

#
SemVerInfo::is_prerelease

source
fn SemVerInfo::is_prerelease(self : SemVerInfo) -> Bool

#
SemVerInfo::is_stable

source
fn SemVerInfo::is_stable(self : SemVerInfo) -> Bool

#
SemVerInfo::next_major

source
fn SemVerInfo::next_major(self : SemVerInfo) -> String

#
SemVerInfo::next_minor

source
fn SemVerInfo::next_minor(self : SemVerInfo) -> String

#
SemVerInfo::next_patch

source
fn SemVerInfo::next_patch(self : SemVerInfo) -> String

#
SemVerInfo::release_channel

source
fn SemVerInfo::release_channel(self : SemVerInfo) -> String

#
SemVerInfo::to_markdown

source
fn SemVerInfo::to_markdown(self : SemVerInfo) -> String

#
Severity

source
pub(all) enum Severity {
  Pass
  Info
  Warning
  Error
} derive(Eq, 
Debug)

#
VersionBump

source
pub(all) enum VersionBump {
  Major
  Minor
  Patch
  SameVersion
  InvalidVersion
} derive(Eq, 
Debug)

#
WorkflowCommand

source
pub(all) struct WorkflowCommand {
  name : String
  command : String
  line : Int
} derive(Eq, 
Debug)

#
WorkflowInfo

source
pub(all) struct WorkflowInfo {
  command_count : Int
  moon_command_count : Int
  has_checkout : Bool
  has_moon_install : Bool
  has_check : Bool
  has_build : Bool
  has_test : Bool
  has_run : Bool
  has_publish_dry_run : Bool
  targets : Array[String]
  commands : Array[WorkflowCommand]
} derive(Eq, 
Debug)

#
WorkflowInfo::coverage_score

source
fn WorkflowInfo::coverage_score(self : WorkflowInfo) -> Int

#
WorkflowInfo::is_acceptance_ready

source
fn WorkflowInfo::is_acceptance_ready(self : WorkflowInfo) -> Bool

#
WorkflowInfo::missing_commands

source
fn WorkflowInfo::missing_commands(self : WorkflowInfo) -> Array[String]

#
WorkflowInfo::summary

source
fn WorkflowInfo::summary(self : WorkflowInfo) -> String

#
WorkflowInfo::to_markdown

source
fn WorkflowInfo::to_markdown(self : WorkflowInfo) -> String

#
acceptance_level_name

source
fn acceptance_level_name(level : AcceptanceLevel) -> String

#
acceptance_reviews_table

source
fn acceptance_reviews_table(reviews : Array[AcceptanceReview]) -> String

#
all_match

source
fn all_match(text : String, items : Array[String]) -> Bool

#
analyze_api_compatibility

source
fn analyze_api_compatibility(before : String, after : String) -> ApiCompatibility

#
analyze_license

source
fn analyze_license(text : String) -> LicenseFacts

#
analyze_namespace

source
fn analyze_namespace(raw : String, repository : String) -> NamespaceInfo

#
analyze_readme

source
fn analyze_readme(readme : String) -> ReadmeMetrics

#
analyze_workflow

source
fn analyze_workflow(text : String) -> WorkflowInfo

#
any_match

source
fn any_match(text : String, items : Array[String]) -> Bool

#
api_snapshot_declarations

source
fn api_snapshot_declarations(snapshot : String) -> Array[String]

#
audit_project

source
fn audit_project(input : AuditInput) -> AuditReport

#
build_acceptance_evidence

source
fn build_acceptance_evidence(input : AuditInput) -> EvidenceMatrix

#
build_quality_matrix

source
fn build_quality_matrix(input : AuditInput) -> QualityMatrix

#
build_release_plan

source
fn build_release_plan(input : AuditInput) -> ReleasePlan

#
canonicalize_token

source
fn canonicalize_token(text : String) -> String

#
classify_version_bump

source
fn classify_version_bump(before : String, after : String) -> VersionBump

#
compare_evidence

source
fn compare_evidence(before : EvidenceMatrix, after : EvidenceMatrix) -> AuditDiff

#
compare_semver

source
fn compare_semver(left : String, right : String) -> Int

#
contains_word

source
fn contains_word(text : String, word : String) -> Bool

#
count_word

source
fn count_word(text : String, word : String) -> Int

#
diff_reports

source
fn diff_reports(before : AuditReport, after : AuditReport) -> AuditDiff

#
evidence_from_report

source
fn evidence_from_report(input : AuditInput, report : AuditReport) -> EvidenceMatrix

#
evidence_markdown_summary

source
fn evidence_markdown_summary(input : AuditInput) -> String

fn extract_inline_link_target(line : String) -> String?

#
extract_inline_link_text

source
fn extract_inline_link_text(line : String) -> String?

#
first_token

source
fn first_token(text : String) -> String

#
github_owner_repo

source
fn github_owner_repo(repository : String) -> Array[String]

#
heading_level

source
fn heading_level(line : String) -> Int

#
heading_text

source
fn heading_text(line : String) -> String

#
is_badge_line

source
fn is_badge_line(line : String) -> Bool

#
is_bullet_line

source
fn is_bullet_line(line : String) -> Bool

#
is_command_line

source
fn is_command_line(line : String) -> Bool

#
is_fence_line

source
fn is_fence_line(line : String) -> Bool

#
is_heading_line

source
fn is_heading_line(line : String) -> Bool

fn is_markdown_link_line(line : String) -> Bool

#
is_numbered_line

source
fn is_numbered_line(line : String) -> Bool

#
last_token

source
fn last_token(text : String) -> String

#
license_compatibility_note

source
fn license_compatibility_note(project : LicenseFacts, dependency : LicenseFacts) -> String

#
license_family_name

source
fn license_family_name(family : LicenseFamily) -> String

#
license_notice_template

source
fn license_notice_template(project : String, holder : String, year : Int) -> String

#
longest_section_title

source
fn longest_section_title(metrics : ReadmeMetrics) -> String

#
mooncakes_package_page

source
fn mooncakes_package_page(package_name : String) -> String

#
namespace_acceptance_issue

source
fn namespace_acceptance_issue(info : NamespaceInfo) -> String

#
namespace_alignment_table

source
fn namespace_alignment_table(items : Array[NamespaceInfo]) -> String

#
namespace_from_manifest

source
fn namespace_from_manifest(manifest : ManifestInfo) -> NamespaceInfo

#
namespace_has_placeholder

source
fn namespace_has_placeholder(name : String) -> Bool

#
package_name_from_repository

source
fn package_name_from_repository(repository : String) -> String

#
parse_manifest

source
fn parse_manifest(text : String) -> ManifestInfo

#
parse_semver

source
fn parse_semver(value : String) -> SemVerInfo

#
quality_axis_named

source
fn quality_axis_named(matrix : QualityMatrix, name : String) -> QualityAxis?

#
quality_from_report

source
fn quality_from_report(input : AuditInput, report : AuditReport) -> QualityMatrix

#
quality_matrix_table

source
fn quality_matrix_table(matrices : Array[QualityMatrix]) -> String

#
readme_topic_table

source
fn readme_topic_table(metrics : ReadmeMetrics) -> String

#
recommend_release_version

source
fn recommend_release_version(current : String, bump : VersionBump) -> String

#
release_plan_from_report

source
fn release_plan_from_report(input : AuditInput, report : AuditReport) -> ReleasePlan

#
release_plan_has_command

source
fn release_plan_has_command(plan : ReleasePlan, command : String) -> Bool

#
release_plan_table

source
fn release_plan_table(plans : Array[ReleasePlan]) -> String

#
remove_trailing_punctuation

source
fn remove_trailing_punctuation(text : String) -> String

#
review_acceptance

source
fn review_acceptance(input : AuditInput) -> AcceptanceReview

#
sample_good_input

source
fn sample_good_input() -> AuditInput

#
sample_risky_input

source
fn sample_risky_input() -> AuditInput

#
semver_accepts_mooncakes_release

source
fn semver_accepts_mooncakes_release(version : String) -> Bool

#
semver_release_table

source
fn semver_release_table(versions : Array[String]) -> String

#
split_tokens

source
fn split_tokens(text : String) -> Array[String]

#
suggested_package_name

source
fn suggested_package_name(owner : String, repo : String) -> String

#
version_bump_name

source
fn version_bump_name(bump : VersionBump) -> String

#
workflow_acceptance_label

source
fn workflow_acceptance_label(info : WorkflowInfo) -> String

#
workflow_command_table

source
fn workflow_command_table(info : WorkflowInfo) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io