🥮 mooncakes.io

moon_doctor

A MoonBit project health checker for release-ready repositories.

moonbit
doctor
quality
release
health-check
moon add sheldonshi115/moon_doctor@0.3.0
Download zip
Version
0.3.0
License
MIT
Repository
Last updated
last month
Downloads
8

Dependencies

README

#Moon Doctor

This file exists for MoonBit documentation workflows. The GitHub-facing project README is README.md.

#
AnalysisContext

source
pub(all) struct AnalysisContext {
  config : DoctorConfig
  inventory : ProjectInventory
  manifest : MoonManifest?
  package_graph : PackageGraph
} derive(Eq, 
Debug)

Shared result of one offline release-quality analysis.

#
AnalysisContext::new

source
fn AnalysisContext::new(config : DoctorConfig, inventory : ProjectInventory, manifest : MoonManifest?, package_graph : PackageGraph) -> AnalysisContext

#
AnalysisContext::snapshot

source

#
CliOptions

source
pub(all) struct CliOptions {
  target : String
  format : OutputFormat
  strict : Bool
  help : Bool
} derive(Eq, 
Debug)

Parsed Moon Doctor command-line options.

#
CommandRequest

source
pub(all) struct CommandRequest {
  command : DoctorCommand
  target : String
  format : OutputFormat
  strict : Bool
  help : Bool
  config_path : String?
  profile : String?
} derive(Eq, 
Debug)

Request parsed from both modern subcommands and legacy check syntax.

#
CommandRequest::default

source

#
Diagnostic

source
pub(all) struct Diagnostic {
  severity : Severity
  code : String
  message : String
  detail : String
  location : SourceLocation?
  remediation : Array[String]
} derive(Eq, 
Debug)

One finding produced by Moon Doctor.

#
Diagnostic::at

source
fn Diagnostic::at(severity : Severity, code : String, message : String, detail : String, location : SourceLocation, remediation : Array[String]) -> Diagnostic

#
Diagnostic::new

source
fn Diagnostic::new(severity : Severity, code : String, message : String, detail : String) -> Diagnostic

#
DiagnosticQuery

source
pub(all) struct DiagnosticQuery {
  severity : Severity?
  category : RuleCategory?
  path_prefix : String?
  include_unlocated : Bool
} derive(Eq, 
Debug)

Immutable query parameters for filtering a DoctorReport.

#
DiagnosticQuery::all

source

#
DiagnosticQuery::count

source
fn DiagnosticQuery::count(self : DiagnosticQuery, report : DoctorReport) -> Int

#
DiagnosticQuery::filter

source

#
DiagnosticQuery::matches

source
fn DiagnosticQuery::matches(self : DiagnosticQuery, diagnostic : Diagnostic) -> Bool

#
DoctorCommand

source
pub(all) enum DoctorCommand {
  Check
  Rules
  Explain(String)
} derive(Eq, 
Debug)

Top-level Moon Doctor command.

#
DoctorConfig

source
pub(all) struct DoctorConfig {
  version : Int
  profile : DoctorProfile
  disabled_rules : Array[String]
  severity_overrides : Map[String, Severity]
  ignore_paths : Array[String]
  required_commands : Array[String]
  release_metadata : Map[String, String]
  source : String
} derive(Eq, 
Debug)

Project-local policy loaded from moon.doctor.json when present.

#
DoctorConfig::default

source
fn DoctorConfig::default(profile? : DoctorProfile) -> DoctorConfig

#
DoctorConfig::ignores_path

source
fn DoctorConfig::ignores_path(self : DoctorConfig, path : String) -> Bool

#
DoctorConfig::is_rule_disabled

source
fn DoctorConfig::is_rule_disabled(self : DoctorConfig, rule_id : String) -> Bool

#
DoctorConfig::release_checklist

source
fn DoctorConfig::release_checklist(self : DoctorConfig) -> Array[String]

#
DoctorConfig::severity_for

source
fn DoctorConfig::severity_for(self : DoctorConfig, rule_id : String, default_severity : Severity) -> Severity

#
DoctorProfile

source
pub(all) enum DoctorProfile {
  Default
  Github
  Mooncakes
  Release
} derive(Eq, 
Debug)

Profiles express the intended publication target without using network APIs.

#
DoctorProfile::label

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

#
DoctorReport

source
pub(all) struct DoctorReport {
  root : String
  diagnostics : Array[Diagnostic]
  score : Score
  profile : String
  checklist : Array[String]
} derive(Eq, 
Debug)

Complete report data before rendering.

#
DoctorReport::conclusion

source
fn DoctorReport::conclusion(self : DoctorReport) -> String

#
DoctorReport::new

source
fn DoctorReport::new(root : String, diagnostics : Array[Diagnostic]) -> DoctorReport

#
DoctorReport::with_context

source
fn DoctorReport::with_context(root : String, diagnostics : Array[Diagnostic], profile : String, checklist : Array[String]) -> DoctorReport

#
ManifestField

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

Field captured from moon.mod or moon.pkg with a stable source line.

#
ManifestField::location

source
fn ManifestField::location(self : ManifestField, path : String) -> SourceLocation

#
ManifestValue

source
pub(all) enum ManifestValue {
  Text(String)
  TextArray(Array[String])
  Raw(String)
} derive(Eq, 
Debug)

Parsed manifest value retained in a form useful to release rules.

#
ManifestValue::as_array

source
fn ManifestValue::as_array(self : ManifestValue) -> Array[String]?

#
ManifestValue::as_text

source
fn ManifestValue::as_text(self : ManifestValue) -> String?

#
MarkdownCodeBlock

source
pub(all) struct MarkdownCodeBlock {
  language : String
  content : String
  start_line : Int
  end_line : Int
} derive(Eq, 
Debug)

Fenced code block discovered from a Markdown document.

#
MarkdownDocument

source
pub(all) struct MarkdownDocument {
  path : String
  headings : Array[MarkdownHeading]
  code_blocks : Array[MarkdownCodeBlock]
  links : Array[String]
  image_links : Array[String]
  command_examples : Array[String]
  line_count : Int
} derive(Eq, 
Debug)

Static facts extracted from a repository Markdown document.

#
MarkdownDocument::has_command

source
fn MarkdownDocument::has_command(self : MarkdownDocument, command : String) -> Bool

#
MarkdownDocument::has_heading

source
fn MarkdownDocument::has_heading(self : MarkdownDocument, expected : String) -> Bool

#
MarkdownDocument::has_heading_casefold

source
fn MarkdownDocument::has_heading_casefold(self : MarkdownDocument, expected : String) -> Bool

#
MarkdownDocument::heading_location

source
fn MarkdownDocument::heading_location(self : MarkdownDocument, expected : String) -> SourceLocation?

#
MarkdownDocument::summary

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

#
MarkdownHeading

source
pub(all) struct MarkdownHeading {
  level : Int
  text : String
  line : Int
} derive(Eq, 
Debug)

Heading discovered from a Markdown document.

#
MetricGroup

source
pub(all) struct MetricGroup {
  name : String
  files : Int
  lines : Int
  characters : Int
} derive(Eq, 
Debug)

Counted file group used for an explainable project inventory summary.

#
MetricGroup::add_file

source
fn MetricGroup::add_file(self : MetricGroup, file : ProjectFile) -> MetricGroup

#
MetricGroup::new

source
fn MetricGroup::new(name : String) -> MetricGroup

#
MoonManifest

source
pub(all) struct MoonManifest {
  path : String
  fields : Array[ManifestField]
  imports : Array[String]
  comments : Int
  nonempty_lines : Int
} derive(Eq, 
Debug)

Lightweight parse of a MoonBit manifest file.

#
MoonManifest::field

source
fn MoonManifest::field(self : MoonManifest, key : String) -> ManifestField?

#
MoonManifest::field_location

source
fn MoonManifest::field_location(self : MoonManifest, key : String) -> SourceLocation?

#
MoonManifest::has_import

source
fn MoonManifest::has_import(self : MoonManifest, package_name : String) -> Bool

#
MoonManifest::new

source
fn MoonManifest::new(path : String, fields : Array[ManifestField], imports : Array[String], comments : Int, nonempty_lines : Int) -> MoonManifest

#
MoonManifest::text

source
fn MoonManifest::text(self : MoonManifest, key : String) -> String?

#
MoonManifest::text_array

source
fn MoonManifest::text_array(self : MoonManifest, key : String) -> Array[String]

#
MoonPackage

source
pub(all) struct MoonPackage {
  path : String
  import_path : String
  manifest : MoonManifest
  source_files : Array[ProjectFile]
  test_files : Array[ProjectFile]
} derive(Eq, 
Debug)

A MoonBit package discovered from a moon.pkg file.

#
MoonPackage::has_source

source
fn MoonPackage::has_source(self : MoonPackage) -> Bool

#
MoonPackage::has_tests

source
fn MoonPackage::has_tests(self : MoonPackage) -> Bool

#
MoonPackage::new

source
fn MoonPackage::new(path : String, import_path : String, manifest : MoonManifest, source_files : Array[ProjectFile], test_files : Array[ProjectFile]) -> MoonPackage

#
OutputFormat

source
pub(all) enum OutputFormat {
  Text
  Json
  Sarif
} derive(Eq, 
Debug)

Output format selected by the command-line interface.

#
OutputFormat::label

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

#
PackageGraph

source
pub(all) struct PackageGraph {
  module_name : String
  packages : Array[MoonPackage]
  local_edges : Map[String, Array[String]]
  missing_local_imports : Array[(String, String)]
  cycles : Array[Array[String]]
} derive(Eq, 
Debug)

Directed graph of local package imports in one MoonBit module.

#
PackageGraph::edge_count

source
fn PackageGraph::edge_count(self : PackageGraph) -> Int

#
PackageGraph::find_package

source
fn PackageGraph::find_package(self : PackageGraph, import_path : String) -> MoonPackage?

#
PackageGraph::new

source
fn PackageGraph::new(module_name : String, packages : Array[MoonPackage], local_edges : Map[String, Array[String]], missing_local_imports : Array[(String, String)], cycles : Array[Array[String]]) -> PackageGraph

#
PackageGraph::package_count

source
fn PackageGraph::package_count(self : PackageGraph) -> Int

#
ProjectFile

source
pub(all) struct ProjectFile {
  path : String
  content : String
  line_count : Int
  char_count : Int
} derive(Eq, 
Debug)

One text file captured during a deterministic project scan.

#
ProjectFile::line_of

source
fn ProjectFile::line_of(self : ProjectFile, needle : String) -> Int?

#
ProjectFile::location_of

source
fn ProjectFile::location_of(self : ProjectFile, needle : String) -> SourceLocation?

#
ProjectFile::new

source
fn ProjectFile::new(path : String, content : String) -> ProjectFile

#
ProjectInventory

source
pub(all) struct ProjectInventory {
  root : String
  files : Array[ProjectFile]
  directories : Array[String]
  ignored_paths : Array[String]
} derive(Eq, 
Debug)

Complete, offline tree inventory for a project root.

#
ProjectInventory::files_under

source
fn ProjectInventory::files_under(self : ProjectInventory, path : String) -> Array[ProjectFile]

#
ProjectInventory::files_with_suffix

source
fn ProjectInventory::files_with_suffix(self : ProjectInventory, suffix : String) -> Array[ProjectFile]

#
ProjectInventory::find_file

source
fn ProjectInventory::find_file(self : ProjectInventory, path : String) -> ProjectFile?

#
ProjectInventory::has_directory

source
fn ProjectInventory::has_directory(self : ProjectInventory, path : String) -> Bool

#
ProjectInventory::has_file

source
fn ProjectInventory::has_file(self : ProjectInventory, path : String) -> Bool

#
ProjectInventory::new

source
fn ProjectInventory::new(root : String, files : Array[ProjectFile], directories : Array[String], ignored_paths : Array[String]) -> ProjectInventory

#
ProjectInventory::to_snapshot

source

#
ProjectInventory::total_lines

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

#
ProjectMetrics

source
pub(all) struct ProjectMetrics {
  root : String
  total_files : Int
  total_directories : Int
  total_lines : Int
  total_characters : Int
  moonbit_source : MetricGroup
  moonbit_tests : MetricGroup
  markdown_docs : MetricGroup
  workflows : MetricGroup
  config_files : MetricGroup
  fixture_files : MetricGroup
  example_files : MetricGroup
  package_count : Int
  local_dependency_edges : Int
  ignored_path_count : Int
} derive(Eq, 
Debug)

Structural metrics produced entirely from local repository contents.

#
ProjectSnapshot

source
pub(all) struct ProjectSnapshot {
  root : String
  files : Map[String, String]
  dirs : Array[String]
} derive(Eq, 
Debug)

Lightweight view of a MoonBit project directory.

#
ProjectSnapshot::field_mentions

source
fn ProjectSnapshot::field_mentions(self : ProjectSnapshot, key : String, needle : String) -> Bool

#
ProjectSnapshot::gitignore_mentions

source
fn ProjectSnapshot::gitignore_mentions(self : ProjectSnapshot, expected : String) -> Bool

#
ProjectSnapshot::has_any_test_file

source
fn ProjectSnapshot::has_any_test_file(self : ProjectSnapshot) -> Bool

#
ProjectSnapshot::has_dir

source
fn ProjectSnapshot::has_dir(self : ProjectSnapshot, path : String) -> Bool

#
ProjectSnapshot::has_exact_file

source
fn ProjectSnapshot::has_exact_file(self : ProjectSnapshot, path : String) -> Bool

#
ProjectSnapshot::has_example_content

source
fn ProjectSnapshot::has_example_content(self : ProjectSnapshot) -> Bool

#
ProjectSnapshot::has_file

source
fn ProjectSnapshot::has_file(self : ProjectSnapshot, path : String) -> Bool

#
ProjectSnapshot::has_readme_file

source
fn ProjectSnapshot::has_readme_file(self : ProjectSnapshot) -> Bool

#
ProjectSnapshot::has_workflow

source
fn ProjectSnapshot::has_workflow(self : ProjectSnapshot) -> Bool

#
ProjectSnapshot::license_mentions

source
fn ProjectSnapshot::license_mentions(self : ProjectSnapshot, expected : String) -> Bool

#
ProjectSnapshot::moon_mod_field

source
fn ProjectSnapshot::moon_mod_field(self : ProjectSnapshot, key : String) -> String?

#
ProjectSnapshot::new

source
fn ProjectSnapshot::new(root : String, files : Map[String, String], dirs : Array[String]) -> ProjectSnapshot

#
ProjectSnapshot::read_file

source
fn ProjectSnapshot::read_file(self : ProjectSnapshot, path : String) -> String?

#
ProjectSnapshot::readme_mentions

source
fn ProjectSnapshot::readme_mentions(self : ProjectSnapshot, needle : String) -> Bool

#
ProjectSnapshot::workflow_mentions

source
fn ProjectSnapshot::workflow_mentions(self : ProjectSnapshot, needle : String) -> Bool

#
QualityArea

source
pub(all) struct QualityArea {
  category : RuleCategory
  possible : Int
  achieved : Int
  errors : Int
  warnings : Int
  infos : Int
  notes : Array[String]
} derive(Eq, 
Debug)

One weighted quality area in a Moon Doctor scorecard.

#
QualityArea::label

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

#
QualityArea::percent

source
fn QualityArea::percent(self : QualityArea) -> Int

#
QualityScorecard

source
pub(all) struct QualityScorecard {
  profile : String
  areas : Array[QualityArea]
  total_possible : Int
  total_achieved : Int
  percentage : Int
  grade : String
} derive(Eq, 
Debug)

Explainable quality score independent of strict pass/fail mode.

#
ReleaseReadiness

source
pub(all) struct ReleaseReadiness {
  profile : DoctorProfile
  module_name : String?
  version : String?
  repository : String?
  license : String?
  readme : String?
  description : String?
  keywords : Array[String]
  has_license_file : Bool
  has_ci : Bool
  has_examples : Bool
  has_tests : Bool
  has_changelog : Bool
  has_contributing : Bool
  has_acceptance : Bool
  required_commands : Array[String]
} derive(Eq, 
Debug)

Release-oriented facts derived from an inventory, manifest and policy.

#
ReleaseReadiness::missing_items

source
fn ReleaseReadiness::missing_items(self : ReleaseReadiness) -> Array[String]

#
ReleaseReadiness::summary

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

#
RemediationPlan

source
pub(all) struct RemediationPlan {
  project : String
  profile : String
  tasks : Array[RemediationTask]
  blocking_tasks : Int
  advisory_tasks : Int
} derive(Eq, 
Debug)

Ordered plan that turns diagnostics into release work.

#
RemediationPlan::is_release_ready

source
fn RemediationPlan::is_release_ready(self : RemediationPlan) -> Bool

#
RemediationPlan::new

source
fn RemediationPlan::new(project : String, profile : String, tasks : Array[RemediationTask]) -> RemediationPlan

#
RemediationTask

source
pub(all) struct RemediationTask {
  priority : Int
  category : RuleCategory
  title : String
  actions : Array[String]
  rule_ids : Array[String]
  blocking : Bool
} derive(Eq, 
Debug)

A grouped release task derived from one or more diagnostics.

#
RemediationTask::new

source
fn RemediationTask::new(priority : Int, category : RuleCategory, title : String, actions : Array[String], rule_ids : Array[String], blocking : Bool) -> RemediationTask

#
ReportBundle

source
pub(all) struct ReportBundle {
  report : DoctorReport
  remediation : RemediationPlan
  scorecard : QualityScorecard
  text : String
  json : String
  sarif : String
  markdown : String
} derive(Eq, 
Debug)

All deterministic report representations produced from one analysis result.

#
ReportBundle::artifact_names

source
fn ReportBundle::artifact_names() -> Array[String]

#
ReportBundle::for_format

source
fn ReportBundle::for_format(self : ReportBundle, format : String) -> String?

#
ReportBundle::new

source

#
ReportBundle::release_ready

source
fn ReportBundle::release_ready(self : ReportBundle) -> Bool

#
ReportBundle::summary_json

source
fn ReportBundle::summary_json(self : ReportBundle) -> String

#
RuleCategory

source
pub(all) enum RuleCategory {
  Manifest
  Package
  Documentation
  Ci
  Release
} derive(Eq, 
Debug)

Quality area that owns a release-readiness rule.

#
RuleCategory::label

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

#
RuleDefinition

source
pub(all) struct RuleDefinition {
  id : String
  category : RuleCategory
  default_severity : Severity
  title : String
  description : String
  remediation : String
  profiles : Array[String]
} derive(Eq, 
Debug)

Stable metadata for an explainable Moon Doctor rule.

#
RuleDefinition::new

source
fn RuleDefinition::new(id : String, category : RuleCategory, default_severity : Severity, title : String, description : String, remediation : String, profiles : Array[String]) -> RuleDefinition

#
Score

source
pub(all) struct Score {
  grade : String
  status : String
  errors : Int
  warnings : Int
  infos : Int
} derive(Eq, 
Debug)

Final score summary for a diagnostic run.

#
Score::from_diagnostics

source
fn Score::from_diagnostics(diagnostics : Array[Diagnostic]) -> Score

#
Severity

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

Severity level for a project health diagnostic.

#
Severity::label

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

#
SourceLocation

source
pub(all) struct SourceLocation {
  path : String
  line : Int
  column : Int
} derive(Eq, 
Debug)

Source location attached to a diagnostic when a parser can identify it.

#
SourceLocation::new

source
fn SourceLocation::new(path : String, line : Int, column : Int) -> SourceLocation

#
WorkflowFacts

source
pub(all) struct WorkflowFacts {
  path : String
  name : String?
  triggers : Array[String]
  permissions : Array[String]
  commands : Array[String]
  actions : Array[String]
  jobs : Array[String]
  has_moon_setup : Bool
  has_moon_check : Bool
  has_moon_build : Bool
  has_moon_test : Bool
  has_moon_package : Bool
  has_artifact_upload : Bool
} derive(Eq, 
Debug)

Static features extracted from one GitHub Actions workflow.

#
WorkflowFacts::new

source
fn WorkflowFacts::new(path : String) -> WorkflowFacts

#
WorkflowFacts::summary

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

#
analyze_project

source
fn analyze_project(root : String, config : DoctorConfig) -> DoctorReport raise

Run the full recursive inventory, package graph, policy and legacy checks.

#
analyze_release_readiness

source
fn analyze_release_readiness(inventory : ProjectInventory, manifest : MoonManifest?, config : DoctorConfig) -> ReleaseReadiness

Derive a release status object without running package or network commands.

#
analyze_workflow

source
fn analyze_workflow(file : ProjectFile) -> WorkflowFacts

Extract release-relevant YAML facts without implementing a general YAML parser.

#
analyze_workflows

source
fn analyze_workflows(inventory : ProjectInventory) -> Array[WorkflowFacts]

#
build_package_graph

source
fn build_package_graph(inventory : ProjectInventory) -> PackageGraph

Build the local package dependency graph from a recursive inventory.

#
build_quality_scorecard

source
fn build_quality_scorecard(report : DoctorReport) -> QualityScorecard

#
build_remediation_plan

source
fn build_remediation_plan(report : DoctorReport) -> RemediationPlan

Build an ordered remediation plan from an analyzed report.

#
calculate_project_metrics

source
fn calculate_project_metrics(inventory : ProjectInventory, graph : PackageGraph) -> ProjectMetrics

#
cli_usage

source
fn cli_usage() -> String

Return the stable command-line usage text.

#
command_usage

source
fn command_usage() -> String

#
default_release_checklist

source
fn default_release_checklist() -> Array[String]

#
diagnose

source
fn diagnose(project : ProjectSnapshot) -> DoctorReport

Run all default-profile health checks. This preserves the original API.

#
diagnose_with_config

source
fn diagnose_with_config(project : ProjectSnapshot, config : DoctorConfig) -> DoctorReport

Run health checks with a project-local release policy.

#
diagnostic_counts_by_category

source
fn diagnostic_counts_by_category(report : DoctorReport) -> Map[String, Int]

#
diagnostic_counts_by_severity

source
fn diagnostic_counts_by_severity(report : DoctorReport) -> Map[String, Int]

#
diagnostic_query_summary

source
fn diagnostic_query_summary(report : DoctorReport, query : DiagnosticQuery) -> String

#
diagnostic_query_to_json

source
fn diagnostic_query_to_json(report : DoctorReport, query : DiagnosticQuery) -> Json

#
documentation_health_report

source
fn documentation_health_report(inventory : ProjectInventory) -> String

#
find_rule_definition

source
fn find_rule_definition(rule_id : String) -> RuleDefinition?

#
load_config

source
fn load_config(root : String, path? : String, profile? : String) -> DoctorConfig raise

Load a project policy or return the selected built-in profile when absent.

#
load_project

source
fn load_project(root : String) -> ProjectSnapshot raise

Load the project files Moon Doctor needs for a first-pass health check.

#
markdown_report_json

source
fn markdown_report_json(report : DoctorReport) -> Json

#
metrics_markdown

source
fn metrics_markdown(metrics : ProjectMetrics) -> String

#
parse_cli_args

source
fn parse_cli_args(args : Array[String]) -> Result[CliOptions, String]

Parse process arguments, including the executable name at index zero.

#
parse_command_request

source
fn parse_command_request(args : Array[String]) -> Result[CommandRequest, String]

Parse process arguments. Omit a subcommand to preserve legacy check usage.

#
parse_inventory_markdown

source
fn parse_inventory_markdown(inventory : ProjectInventory) -> Array[MarkdownDocument]

#
parse_manifest

source
fn parse_manifest(path : String, content : String) -> MoonManifest

Parse moon.mod or moon.pkg without requiring a general TOML parser.

#
parse_manifest_file

source
fn parse_manifest_file(file : ProjectFile) -> MoonManifest

#
parse_markdown

source
fn parse_markdown(path : String, content : String) -> MarkdownDocument

Parse common Markdown structures without depending on a browser or network.

#
parse_root_manifest

source
fn parse_root_manifest(inventory : ProjectInventory) -> MoonManifest?

#
project_metrics_to_json

source
fn project_metrics_to_json(metrics : ProjectMetrics) -> Json

#
project_name

source
let project_name : String

Human-readable project name.

#
quality_scorecard_to_json

source
fn quality_scorecard_to_json(scorecard : QualityScorecard) -> Json

#
readme_document

source
fn readme_document(inventory : ProjectInventory) -> MarkdownDocument?

#
release_readiness_to_json

source
fn release_readiness_to_json(readiness : ReleaseReadiness) -> Json

#
remediation_plan_to_json

source
fn remediation_plan_to_json(plan : RemediationPlan) -> Json

#
render_bundle_index

source
fn render_bundle_index(bundle : ReportBundle) -> String

#
render_bundle_markdown

source
fn render_bundle_markdown(bundle : ReportBundle) -> String

#
render_diagnostic_query

source
fn render_diagnostic_query(report : DoctorReport, query : DiagnosticQuery) -> String

#
render_json_report

source
fn render_json_report(report : DoctorReport) -> String

Render a deterministic JSON report for CI and other local tooling.

#
render_markdown_report

source
fn render_markdown_report(report : DoctorReport) -> String

Render a reviewer-friendly report for pull requests and release notes.

#
render_project_metrics

source
fn render_project_metrics(metrics : ProjectMetrics) -> String

#
render_quality_scorecard

source
fn render_quality_scorecard(scorecard : QualityScorecard) -> String

#
render_release_readiness

source
fn render_release_readiness(readiness : ReleaseReadiness) -> String

#
render_remediation_markdown

source
fn render_remediation_markdown(plan : RemediationPlan) -> String

#
render_report

source
fn render_report(report : DoctorReport) -> String

Render a report as plain text for terminals, CI logs, and README examples.

#
render_rule_catalog

source
fn render_rule_catalog() -> String

#
render_rule_explanation

source
fn render_rule_explanation(rule_id : String) -> String?

#
render_rule_explanation_json

source
fn render_rule_explanation_json(rule_id : String) -> String?

#
render_sarif_report

source
fn render_sarif_report(report : DoctorReport) -> String

Render a deterministic SARIF 2.1.0 document for GitHub Code Scanning.

#
report_json_schema

source
let report_json_schema : String

Stable schema name for machine-readable Moon Doctor reports.

#
rule_catalog

source
fn rule_catalog() -> Array[RuleDefinition]

Return the complete stable v1 rule catalog.

#
rules_for_profile

source
fn rules_for_profile(profile : DoctorProfile) -> Array[RuleDefinition]

#
scan_project

source
fn scan_project(root : String, config : DoctorConfig) -> ProjectInventory raise

Recursively scan a project without touching ignored or generated directories.

#
scan_project_default

source
fn scan_project_default(root : String) -> ProjectInventory raise

#
should_fail_strict

source
fn should_fail_strict(options : CliOptions, report : DoctorReport) -> Bool

Strict mode blocks release workflows on errors and warnings, not INFO advice.

#
workflow_release_report

source
fn workflow_release_report(inventory : ProjectInventory) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io