🥮 mooncakes.io

    bitx_hub

    Local PR/Issue metadata + GitHub sync (extension module for mizchi/bit)

    git
    hub
    pr
    issue
    Download zip
    Author
    Version
    0.48.0
    License
    Apache-2.0
    Repository
    Last updated
    9 days ago
    Downloads
    129

    Dependencies

    PrError

    source
    pub(all) suberror PrError {
      NotFound(String)
      InvalidFormat(String)
      InvalidState(String)
      MergeConflict(Array[String])
    } derive(Eq, 
    Debug    )

    PR operation error

    ClaimAction

    source
    pub(all) enum ClaimAction {
      Claim
      Unclaim
    } derive(Eq, 
    Debug    )

    impl Show for ClaimAction

    ClaimAction::to_string

    source
    fn ClaimAction::to_string(self : ClaimAction) -> String

    ClaimMessage

    source
    pub struct ClaimMessage {
      issue_id : String
      action : ClaimAction
      claimer : String
      timestamp : Int64
    } derive(Eq, 
    Debug    )

    ClaimMessage::action

    source
    fn ClaimMessage::action(self : ClaimMessage) -> ClaimAction

    ClaimMessage::claimer

    source
    fn ClaimMessage::claimer(self : ClaimMessage) -> String

    ClaimMessage::is_stale

    source
    fn ClaimMessage::is_stale(self : ClaimMessage, now : Int64, threshold_hours? : Int) -> Bool

    Check if a claim is stale based on the threshold.

    ClaimMessage::issue_id

    source
    fn ClaimMessage::issue_id(self : ClaimMessage) -> String

    ClaimMessage::new

    source
    fn ClaimMessage::new(issue_id : String, action : ClaimAction, claimer : String, timestamp : Int64) -> ClaimMessage

    ClaimMessage::timestamp

    source
    fn ClaimMessage::timestamp(self : ClaimMessage) -> Int64

    ClaimMessage::to_json

    source
    fn ClaimMessage::to_json(self : ClaimMessage) -> Json

    GhComment

    source
    pub struct GhComment {
      id : Int
      node_id : String
      body : String
      user : String
      created_at : String
      updated_at : String
    }

    GitHub Comment from REST API

    GhComment::from_json

    source
    fn GhComment::from_json(obj : Map[String, Json]) -> GhComment

    GhIssue

    source
    pub struct GhIssue {
      number : Int
      node_id : String
      title : String
      body : String
      state : String
      user : String
      labels : Array[String]
      assignees : Array[String]
      created_at : String
      updated_at : String
    }

    GitHub Issue from REST API

    GhIssue::from_json

    source
    fn GhIssue::from_json(obj : Map[String, Json]) -> GhIssue

    GhPullRequest

    source
    pub struct GhPullRequest {
      number : Int
      node_id : String
      title : String
      body : String
      state : String
      user : String
      head_ref : String
      head_repo : String
      base_ref : String
      labels : Array[String]
      created_at : String
      updated_at : String
      merged : Bool
      merged_at : String
    }

    GitHub Pull Request from REST API

    GhPullRequest::from_json

    source
    fn GhPullRequest::from_json(obj : Map[String, Json]) -> GhPullRequest

    Hub

    source
    pub struct Hub {
      store : HubStore
    }

    Hub manages Pull Requests and Issues stored in git notes

    Hub::add_comment

    source
    fn Hub::add_comment(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , pr_id : String, author : String, body : String, reply_to? : String?, file_path? : String?, line_number? : Int?, commit_id? : 
    ObjectId    ?) -> PrComment raise 
    GitError

    Add a comment to a Pull Request

    Hub::add_dep

    source
    fn Hub::add_dep(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , source_id : String, target_id : String) -> Unit raise 
    GitError

    Add a dependency relationship between two issues. source_id is blocked by target_id. Both issues are updated in separate put_record calls.

    Hub::add_issue_comment

    source
    fn Hub::add_issue_comment(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, author : String, body : String, reply_to? : String?) -> IssueComment raise 
    GitError

    Add a comment to an Issue

    Hub::add_note

    source
    fn Hub::add_note(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , commit_id : 
    ObjectId    , body : String, author : String, timestamp : Int64, ns? : String) -> Note raise 
    GitError

    Add a note to a commit (Git compatible)

    Hub::add_note_plain

    source
    fn Hub::add_note_plain(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , commit_id : 
    ObjectId    , body : String, ns? : String) -> Unit raise 
    GitError

    Add a plain note (Git standard, no metadata)

    Hub::broadcast_feature

    source
    fn Hub::broadcast_feature(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , branch_name : String, tip_commit : String, author : String, summary? : String, closes_issues? : Array[String], session_url? : String?) -> Unit raise 
    GitError

    Broadcast a feature completion notification (notify-only record)

    Hub::can_merge

    source
    fn Hub::can_merge(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , pr_id : String) -> Bool raise 
    GitError

    Check if a PR can be merged (no conflicts, PR is open)

    Hub::check_merge_policy

    source
    fn Hub::check_merge_policy(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , pr_id : String, policy : PrMergePolicy, signing_key? : String?) -> Unit raise 
    GitError

    Hub::close_issue

    source
    fn Hub::close_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String) -> Unit raise 
    GitError

    Close an Issue

    Hub::close_pr

    source

    Close a Pull Request

    Hub::create_issue

    source
    fn Hub::create_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , title : String, body : String, author : String, labels? : Array[String], assignees? : Array[String], parent_id? : String?) -> Issue raise 
    GitError

    Create a new Issue

    Hub::create_pr

    source
    fn Hub::create_pr(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , title : String, body : String, source_branch : String, target_branch : String, author : String, source_repo? : String?, source_ref? : String?) -> PullRequest raise 
    GitError

    Create a new Pull Request

    Hub::delete_issue_comment

    source
    fn Hub::delete_issue_comment(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, comment_id : String) -> Unit raise 
    GitError

    Delete a comment from an Issue

    Hub::find_canonical_node

    source
    fn Hub::find_canonical_node(self : Hub, objects : &
    ObjectStore    ) -> String?

    Determine the canonical node from heartbeat records. Returns the node_id of the most active node (highest vector clock, then highest commit count).
    fn Hub::find_sync_link_by_remote(self : Hub, objects : &
    ObjectStore    , provider : String, repo : String, remote_number : Int) -> SyncLink?

    Find a SyncLink by provider, repo, and remote number

    Hub::get_issue

    source
    fn Hub::get_issue(self : Hub, objects : &
    ObjectStore    , issue_id : String) -> Issue?

    Get an Issue by ID

    Hub::get_note

    source

    Get a note for a commit

    Hub::get_pr

    source
    fn Hub::get_pr(self : Hub, objects : &
    ObjectStore    , pr_id : String) -> PullRequest?

    Get a Pull Request by ID
    fn Hub::get_sync_link(self : Hub, objects : &
    ObjectStore    , local_id : String, provider : String) -> SyncLink?

    Retrieve a SyncLink by local_id and provider

    Hub::get_work_item

    source
    fn Hub::get_work_item(self : Hub, objects : &
    ObjectStore    , work_item_id : String) -> WorkItem?

    Hub::import_issues

    source

    Hub::import_pr_proposals

    source

    Hub::import_prs

    source

    Hub::init

    source
    fn Hub::init(objects : &
    ObjectStore    , refs : &
    RefStore    , node_id? : String, signing_key? : String?, require_signed? : Bool) -> Hub raise 
    GitError

    Initialize a new Hub

    Hub::is_approved

    source
    fn Hub::is_approved(self : Hub, objects : &
    ObjectStore    , pr_id : String) -> Bool

    Check if a PR is approved (has at least one Approved review with no RequestChanges after it)
    fn Hub::link_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, target_ref : String) -> Unit raise 
    GitError

    Link a cross-repo issue reference to an Issue
    fn Hub::link_pr_to_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, pr_id : String) -> Unit raise 
    GitError

    Link a PR to an Issue

    Hub::list_comments

    source
    fn Hub::list_comments(self : Hub, objects : &
    ObjectStore    , pr_id : String) -> Array[PrComment]

    List comments for a Pull Request

    Hub::list_feature_broadcasts

    source
    fn Hub::list_feature_broadcasts(self : Hub, objects : &
    ObjectStore    ) -> Array[HubRecord]

    List feature broadcast records

    Hub::list_issue_comments

    source
    fn Hub::list_issue_comments(self : Hub, objects : &
    ObjectStore    , issue_id : String) -> Array[IssueComment]

    List comments for an Issue

    Hub::list_issues

    source
    fn Hub::list_issues(self : Hub, objects : &
    ObjectStore    , state? : IssueState?) -> Array[Issue]

    List Issues, optionally filtered by state

    Hub::list_node_heartbeats

    source
    fn Hub::list_node_heartbeats(self : Hub, objects : &
    ObjectStore    ) -> Array[NodeHeartbeat]

    List all node heartbeats and determine which node is canonical. The canonical node is the one with the highest vector clock.

    Hub::list_notes

    source

    List all notes in a ns

    Hub::list_pr_proposals

    source
    fn Hub::list_pr_proposals(self : Hub, objects : &
    ObjectStore    ) -> Array[PullRequest]

    Hub::list_pr_workflows

    source
    fn Hub::list_pr_workflows(self : Hub, objects : &
    ObjectStore    , pr_id : String) -> Array[PrWorkflowResult]

    Hub::list_prs

    source
    fn Hub::list_prs(self : Hub, objects : &
    ObjectStore    , state? : PrState?) -> Array[PullRequest]

    List Pull Requests, optionally filtered by state

    Hub::list_reviews

    source
    fn Hub::list_reviews(self : Hub, objects : &
    ObjectStore    , pr_id : String) -> Array[PrReview]

    List reviews for a Pull Request

    Hub::list_sub_issues

    source
    fn Hub::list_sub_issues(self : Hub, objects : &
    ObjectStore    , parent_id : String, state? : IssueState?) -> Array[Issue]

    List sub-issues of a parent issue
    fn Hub::list_sync_links(self : Hub, objects : &
    ObjectStore    , repo? : String) -> Array[SyncLink]

    List all SyncLinks, optionally filtered by repo

    Hub::list_work_items

    source
    fn Hub::list_work_items(self : Hub, objects : &
    ObjectStore    , state? : WorkItemState?, kind? : WorkItemKind?) -> Array[WorkItem]

    Hub::load

    source
    fn Hub::load(objects : &
    ObjectStore    , refs : &
    RefStore    , node_id? : String, signing_key? : String?, require_signed? : Bool) -> Hub raise 
    GitError

    Load an existing Hub from git notes

    Hub::merge_pr

    source
    fn Hub::merge_pr(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , pr_id : String, merger : String, strategy? : PrMergeStrategy) -> PrMergeResult raise 
    GitError

    Merge a Pull Request

    Hub::propose_pr

    source
    fn Hub::propose_pr(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , title : String, body : String, source_branch : String, target_branch : String, author : String, source_repo? : String?, source_ref? : String?, closes_issues? : Array[String]) -> PullRequest raise 
    GitError

    Create a PR proposal record (notify-only event stream)

    Hub::publish_node_heartbeat

    source
    fn Hub::publish_node_heartbeat(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , node_id : String, commit_count? : Int, main_tip? : String) -> Unit raise 
    GitError

    Publish node heartbeat record for canonical node election. Each node periodically publishes its metadata (commit count, last update time).

    Store a SyncLink as a hub record

    Hub::record_pr_workflow

    source
    fn Hub::record_pr_workflow(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , pr_id : String, task : String, status : PrWorkflowStatus, workspace_fingerprint : String, author : String, txn_id? : String?, summary? : String) -> PrWorkflowResult raise 
    GitError

    Hub::reload_store

    source

    Reload store from current object/ref state

    Hub::remove_dep

    source
    fn Hub::remove_dep(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , source_id : String, target_id : String) -> Unit raise 
    GitError

    Remove a dependency relationship between two issues. source_id is no longer blocked by target_id.

    Hub::remove_note

    source

    Remove a note from a commit

    Hub::reopen_issue

    source
    fn Hub::reopen_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String) -> Unit raise 
    GitError

    Reopen a closed Issue

    Hub::reopen_pr

    source

    Reopen a closed Pull Request

    Hub::submit_review

    source
    fn Hub::submit_review(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , pr_id : String, author : String, verdict : ReviewVerdict, body : String, commit_id : 
    ObjectId    ) -> PrReview raise 
    GitError

    Submit a review for a Pull Request

    Hub::update_issue

    source
    fn Hub::update_issue(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, title? : String?, body? : String?, labels? : Array[String]?, assignees? : Array[String]?) -> Issue raise 
    GitError

    Update an Issue (title, body, labels, assignees)

    Hub::update_issue_comment

    source
    fn Hub::update_issue_comment(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , issue_id : String, comment_id : String, body : String, author : String) -> Unit raise 
    GitError

    Update an existing comment on an Issue (replace body, keep id/timestamps)

    Hub::update_pr

    source
    fn Hub::update_pr(self : Hub, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , pr_id : String, title? : String?, body? : String?, labels? : Array[String]?) -> PullRequest raise 
    GitError

    Update a Pull Request (title, body, labels)

    HubRecord

    source
    pub struct HubRecord {
      version : Int
      key : String
      kind : String
      clock : Map[String, Int64]
      timestamp : Int64
      node : String
      deleted : Bool
      signature : String?
      payload : String
    }

    HubRecord::new

    source
    fn HubRecord::new(key : String, kind : String, payload : String, node : String, timestamp : Int64, clock? : Map[String, Int64], deleted? : Bool, version? : Int, signature? : String?) -> HubRecord

    HubRecord::serialize

    source
    fn HubRecord::serialize(self : HubRecord) -> String

    HubStore

    source
    pub struct HubStore {
      node_id : String
      signing_key : String?
      require_signed : Bool
      entries : Map[String, 
    ObjectId    ]
      head : 
    ObjectId    ?
    }

    HubStore::delete_record

    source
    fn HubStore::delete_record(self : HubStore, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , key : String, kind : String, node : String) -> HubRecord raise 
    GitError

    HubStore::get_record

    source
    fn HubStore::get_record(self : HubStore, objects : &
    ObjectStore    , key : String) -> HubRecord?

    HubStore::list_records

    source
    fn HubStore::list_records(self : HubStore, objects : &
    ObjectStore    , prefix : String, include_deleted? : Bool) -> Array[HubRecord]

    HubStore::load

    source
    fn HubStore::load(objects : &
    ObjectStore    , refs : &
    RefStore    , node_id? : String, signing_key? : String?, require_signed? : Bool) -> HubStore raise 
    GitError

    HubStore::node_id

    source
    fn HubStore::node_id(self : HubStore) -> String

    HubStore::put_record

    source
    fn HubStore::put_record(self : HubStore, objects : &
    ObjectStore    , refs : &
    RefStore    , clock : &
    Clock    , key : String, kind : String, payload : String, node : String) -> HubRecord raise 
    GitError

    HubStore::require_signed

    source
    fn HubStore::require_signed(self : HubStore) -> Bool

    HubStore::signing_key

    source
    fn HubStore::signing_key(self : HubStore) -> String?

    ImportStats

    source
    pub struct ImportStats {
      created : Int
      updated : Int
    }

    ImportStats::created

    source
    fn ImportStats::created(self : ImportStats) -> Int

    ImportStats::new

    source
    fn ImportStats::new(created : Int, updated : Int) -> ImportStats

    ImportStats::updated

    source
    fn ImportStats::updated(self : ImportStats) -> Int

    Issue

    source
    pub struct Issue {
      id : String
      title : String
      body : String
      author : String
      created_at : Int64
      updated_at : Int64
      state : IssueState
      labels : Array[String]
      assignees : Array[String]
      linked_prs : Array[String]
      linked_issues : Array[String]
      parent_id : String?
      blocked_by : Array[String]
      blocking : Array[String]
    }

    Issue data

    Issue::assignees

    source
    fn Issue::assignees(self : Issue) -> Array[String]

    Issue::author

    source
    fn Issue::author(self : Issue) -> String

    Issue::blocked_by

    source
    fn Issue::blocked_by(self : Issue) -> Array[String]

    Issue::blocking

    source
    fn Issue::blocking(self : Issue) -> Array[String]

    Issue::body

    source
    fn Issue::body(self : Issue) -> String

    Issue::created_at

    source
    fn Issue::created_at(self : Issue) -> Int64

    Issue::id

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

    Issue::labels

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

    Issue::linked_issues

    source
    fn Issue::linked_issues(self : Issue) -> Array[String]

    Issue::linked_prs

    source
    fn Issue::linked_prs(self : Issue) -> Array[String]

    Issue::new

    source
    fn Issue::new(id : String, title : String, body : String, author : String, created_at : Int64, updated_at : Int64, state : IssueState, labels? : Array[String], assignees? : Array[String], linked_prs? : Array[String], linked_issues? : Array[String], parent_id? : String?, blocked_by? : Array[String], blocking? : Array[String]) -> Issue

    Issue::serialize

    source
    fn Issue::serialize(self : Issue) -> String

    Serialize Issue to Git-style text format

    Issue::state

    source
    fn Issue::state(self : Issue) -> IssueState

    Issue::title

    source
    fn Issue::title(self : Issue) -> String

    Issue::to_work_item

    source
    fn Issue::to_work_item(self : Issue) -> WorkItem

    Issue::updated_at

    source
    fn Issue::updated_at(self : Issue) -> Int64

    IssueComment

    source
    pub struct IssueComment {
      id : String
      issue_id : String
      author : String
      body : String
      created_at : Int64
      reply_to : String?
    }

    Comment on an Issue

    IssueComment::author

    source
    fn IssueComment::author(self : IssueComment) -> String

    IssueComment::body

    source
    fn IssueComment::body(self : IssueComment) -> String

    IssueComment::created_at

    source
    fn IssueComment::created_at(self : IssueComment) -> Int64

    IssueComment::id

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

    IssueComment::issue_id

    source
    fn IssueComment::issue_id(self : IssueComment) -> String

    IssueComment::new

    source
    fn IssueComment::new(id : String, issue_id : String, author : String, body : String, created_at : Int64, reply_to? : String?) -> IssueComment

    IssueComment::reply_to

    source
    fn IssueComment::reply_to(self : IssueComment) -> String?

    IssueComment::serialize

    source
    fn IssueComment::serialize(self : IssueComment) -> String

    Serialize IssueComment to Git-style text format

    IssueState

    source
    pub(all) enum IssueState {
      Open
      Closed
    } derive(Eq, 
    Debug    )

    State of an Issue
    impl Show for IssueState

    IssueState::to_string

    source
    fn IssueState::to_string(self : IssueState) -> String

    IssueState::to_work_item_state

    source
    fn IssueState::to_work_item_state(self : IssueState) -> WorkItemState

    NodeHeartbeat

    source
    pub struct NodeHeartbeat {
      node_id : String
      commit_count : Int
      main_tip : String
      timestamp : Int64
      clock : Map[String, Int64]
    }

    Node metadata extracted from heartbeat records

    Note

    source
    pub struct Note {
      commit_id : 
    ObjectId
      body : String
      author : String
      created_at : Int64
      ns : String
    }

    Note attached to a commit (Git notes compatible)

    Note::author

    source
    fn Note::author(self : Note) -> String

    Note::body

    source
    fn Note::body(self : Note) -> String

    Note::commit_id

    source

    Note::created_at

    source
    fn Note::created_at(self : Note) -> Int64

    Note::new

    source
    fn Note::new(commit_id : 
    ObjectId    , body : String, author : String, created_at : Int64, ns? : String) -> Note

    Note::ns

    source
    fn Note::ns(self : Note) -> String

    Note::serialize

    source
    fn Note::serialize(self : Note) -> String

    Serialize Note to Git-style text format Note: Git standard notes are plain text, but we add metadata for Hub

    Note::serialize_plain

    source
    fn Note::serialize_plain(self : Note) -> String

    Serialize Note as plain text (Git compatible, no metadata)

    PrComment

    source
    pub struct PrComment {
      id : String
      pr_id : String
      author : String
      body : String
      created_at : Int64
      reply_to : String?
      file_path : String?
      line_number : Int?
      commit_id : 
    ObjectId    ?
    }

    Comment on a Pull Request

    PrComment::author

    source
    fn PrComment::author(self : PrComment) -> String

    PrComment::body

    source
    fn PrComment::body(self : PrComment) -> String

    PrComment::commit_id

    source

    PrComment::created_at

    source
    fn PrComment::created_at(self : PrComment) -> Int64

    PrComment::file_path

    source
    fn PrComment::file_path(self : PrComment) -> String?

    PrComment::id

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

    PrComment::line_number

    source
    fn PrComment::line_number(self : PrComment) -> Int?

    PrComment::new

    source
    fn PrComment::new(id : String, pr_id : String, author : String, body : String, created_at : Int64, reply_to? : String?, file_path? : String?, line_number? : Int?, commit_id? : 
    ObjectId    ?) -> PrComment

    PrComment::pr_id

    source
    fn PrComment::pr_id(self : PrComment) -> String

    PrComment::reply_to

    source
    fn PrComment::reply_to(self : PrComment) -> String?

    PrComment::serialize

    source
    fn PrComment::serialize(self : PrComment) -> String

    Serialize PrComment to Git-style text format

    PrMergePolicy

    source
    pub struct PrMergePolicy {
      required_approvals : Int
      allow_request_changes : Bool
      require_signed_records : Bool
      required_workflows : Array[String]
    }

    PrMergePolicy::allow_request_changes

    source
    fn PrMergePolicy::allow_request_changes(self : PrMergePolicy) -> Bool

    PrMergePolicy::default

    source
    fn PrMergePolicy::default() -> PrMergePolicy

    PrMergePolicy::new

    source
    fn PrMergePolicy::new(required_approvals : Int, allow_request_changes : Bool, require_signed_records : Bool, required_workflows? : Array[String]) -> PrMergePolicy

    PrMergePolicy::require_signed_records

    source
    fn PrMergePolicy::require_signed_records(self : PrMergePolicy) -> Bool

    PrMergePolicy::required_approvals

    source
    fn PrMergePolicy::required_approvals(self : PrMergePolicy) -> Int

    PrMergePolicy::required_workflows

    source
    fn PrMergePolicy::required_workflows(self : PrMergePolicy) -> Array[String]

    PrMergeResult

    source
    pub struct PrMergeResult {
      success : Bool
      commit_id : 
    ObjectId    ?
      conflicts : Array[String]
      message : String
    }

    PrMergeResult::commit_id

    source

    PrMergeResult::conflicts

    source
    fn PrMergeResult::conflicts(self : PrMergeResult) -> Array[String]

    PrMergeResult::message

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

    PrMergeResult::success

    source
    fn PrMergeResult::success(self : PrMergeResult) -> Bool

    PrMergeStrategy

    source
    pub(all) enum PrMergeStrategy {
      Merge
      Squash
      FastForward
    }

    PrReview

    source
    pub struct PrReview {
      id : String
      pr_id : String
      author : String
      verdict : ReviewVerdict
      body : String
      created_at : Int64
      commit_id : 
    ObjectId
    }

    Review on a Pull Request

    PrReview::author

    source
    fn PrReview::author(self : PrReview) -> String

    PrReview::body

    source
    fn PrReview::body(self : PrReview) -> String

    PrReview::commit_id

    source

    PrReview::created_at

    source
    fn PrReview::created_at(self : PrReview) -> Int64

    PrReview::id

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

    PrReview::new

    source
    fn PrReview::new(id : String, pr_id : String, author : String, verdict : ReviewVerdict, body : String, created_at : Int64, commit_id : 
    ObjectId    ) -> PrReview

    PrReview::pr_id

    source
    fn PrReview::pr_id(self : PrReview) -> String

    PrReview::serialize

    source
    fn PrReview::serialize(self : PrReview) -> String

    Serialize PrReview to Git-style text format

    PrReview::verdict

    source
    fn PrReview::verdict(self : PrReview) -> ReviewVerdict

    PrState

    source
    pub(all) enum PrState {
      Open
      Merged
      Closed
    } derive(Eq, 
    Debug    )

    State of a Pull Request
    impl Show for PrState

    PrState::to_string

    source
    fn PrState::to_string(self : PrState) -> String

    PrState::to_work_item_state

    source
    fn PrState::to_work_item_state(self : PrState) -> WorkItemState

    PrSyncResult

    source
    pub struct PrSyncResult {
      success : Bool
      message : String
      local_commit : 
    ObjectId    ?
      remote_commit : 
    ObjectId    ?
    }

    PrSyncResult::local_commit

    source

    PrSyncResult::message

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

    PrSyncResult::new

    source
    fn PrSyncResult::new(success : Bool, message : String, local_commit : 
    ObjectId    ?, remote_commit : 
    ObjectId    ?) -> PrSyncResult

    PrSyncResult::remote_commit

    source

    PrSyncResult::success

    source
    fn PrSyncResult::success(self : PrSyncResult) -> Bool

    PrWorkflowResult

    source
    pub struct PrWorkflowResult {
      pr_id : String
      task : String
      status : PrWorkflowStatus
      workspace_fingerprint : String
      txn_id : String?
      author : String
      updated_at : Int64
      summary : String
    }

    PrWorkflowResult::author

    source
    fn PrWorkflowResult::author(self : PrWorkflowResult) -> String

    PrWorkflowResult::new

    source
    fn PrWorkflowResult::new(pr_id : String, task : String, status : PrWorkflowStatus, workspace_fingerprint : String, author : String, updated_at : Int64, txn_id? : String?, summary? : String) -> PrWorkflowResult

    PrWorkflowResult::pr_id

    source
    fn PrWorkflowResult::pr_id(self : PrWorkflowResult) -> String

    PrWorkflowResult::serialize

    source
    fn PrWorkflowResult::serialize(self : PrWorkflowResult) -> String

    PrWorkflowResult::status

    source

    PrWorkflowResult::summary

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

    PrWorkflowResult::task

    source
    fn PrWorkflowResult::task(self : PrWorkflowResult) -> String

    PrWorkflowResult::txn_id

    source
    fn PrWorkflowResult::txn_id(self : PrWorkflowResult) -> String?

    PrWorkflowResult::updated_at

    source
    fn PrWorkflowResult::updated_at(self : PrWorkflowResult) -> Int64

    PrWorkflowResult::workspace_fingerprint

    source
    fn PrWorkflowResult::workspace_fingerprint(self : PrWorkflowResult) -> String

    PrWorkflowStatus

    source
    pub(all) enum PrWorkflowStatus {
      Pending
      Running
      Success
      Failed
    } derive(Eq, 
    Debug    )

    PrWorkflowStatus::to_string

    source
    fn PrWorkflowStatus::to_string(self : PrWorkflowStatus) -> String

    PullRequest

    source
    pub struct PullRequest {
      id : String
      title : String
      body : String
      source_branch : String
      source_repo : String?
      source_ref : String?
      source_commit : 
    ObjectId
      target_branch : String
      target_commit : 
    ObjectId
      author : String
      created_at : Int64
      updated_at : Int64
      state : PrState
      labels : Array[String]
      closes_issues : Array[String]
      merge_commit : 
    ObjectId    ?
    }

    Pull Request data

    PullRequest::author

    source
    fn PullRequest::author(self : PullRequest) -> String

    PullRequest::body

    source
    fn PullRequest::body(self : PullRequest) -> String

    PullRequest::closes_issues

    source
    fn PullRequest::closes_issues(self : PullRequest) -> Array[String]

    PullRequest::created_at

    source
    fn PullRequest::created_at(self : PullRequest) -> Int64

    PullRequest::id

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

    PullRequest::labels

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

    PullRequest::merge_commit

    source

    PullRequest::new

    source
    fn PullRequest::new(id : String, title : String, body : String, source_branch : String, source_commit : 
    ObjectId    , target_branch : String, target_commit : 
    ObjectId    , author : String, created_at : Int64, updated_at : Int64, state : PrState, labels : Array[String], closes_issues? : Array[String], merge_commit? : 
    ObjectId    ?, source_repo? : String?, source_ref? : String?) -> PullRequest

    PullRequest::serialize

    source
    fn PullRequest::serialize(self : PullRequest) -> String

    Serialize PullRequest to Git-style text format

    PullRequest::source_branch

    source
    fn PullRequest::source_branch(self : PullRequest) -> String

    PullRequest::source_commit

    source

    PullRequest::source_ref

    source
    fn PullRequest::source_ref(self : PullRequest) -> String?

    PullRequest::source_repo

    source
    fn PullRequest::source_repo(self : PullRequest) -> String?

    PullRequest::state

    source
    fn PullRequest::state(self : PullRequest) -> PrState

    PullRequest::target_branch

    source
    fn PullRequest::target_branch(self : PullRequest) -> String

    PullRequest::target_commit

    source

    PullRequest::title

    source
    fn PullRequest::title(self : PullRequest) -> String

    PullRequest::to_work_item

    source
    fn PullRequest::to_work_item(self : PullRequest) -> WorkItem

    PullRequest::updated_at

    source
    fn PullRequest::updated_at(self : PullRequest) -> Int64

    RecordMergePolicy

    source
    pub enum RecordMergePolicy {
      Lww
      TombstoneWins
    }

    RecordTriggerClass

    source
    pub(all) enum RecordTriggerClass {
      Full
      NotifyOnly
    } derive(Eq, 
    Debug    )

    ReviewVerdict

    source
    pub(all) enum ReviewVerdict {
      Approved
      RequestChanges
      Comment
    } derive(Eq, 
    Debug    )

    Review verdict

    ReviewVerdict::to_string

    source
    fn ReviewVerdict::to_string(self : ReviewVerdict) -> String

    SyncDiff

    source
    pub struct SyncDiff {
      title_changed : Bool
      body_changed : Bool
      state_changed : Bool
      labels_changed : Bool
      assignees_changed : Bool
      has_changes : Bool
    }

    Describes what changed between a local Issue and a GitHub GhIssue
    pub struct SyncLink {
      local_id : String
      local_kind : String
      provider : String
      repo : String
      remote_number : Int
      remote_node_id : String
      last_pull_at : Int64
      last_push_at : Int64
      remote_updated_at : Int64
    }

    Tracks the mapping between a local bit work item and a remote GitHub issue/PR

    SyncLink::last_pull_at

    source
    fn SyncLink::last_pull_at(self : SyncLink) -> Int64

    SyncLink::last_push_at

    source
    fn SyncLink::last_push_at(self : SyncLink) -> Int64

    SyncLink::local_id

    source
    fn SyncLink::local_id(self : SyncLink) -> String

    SyncLink::local_kind

    source
    fn SyncLink::local_kind(self : SyncLink) -> String

    SyncLink::new

    source
    fn SyncLink::new(local_id : String, local_kind : String, provider : String, repo : String, remote_number? : Int, remote_node_id? : String, last_pull_at? : Int64, last_push_at? : Int64, remote_updated_at? : Int64) -> SyncLink

    SyncLink::provider

    source
    fn SyncLink::provider(self : SyncLink) -> String

    SyncLink::remote_node_id

    source
    fn SyncLink::remote_node_id(self : SyncLink) -> String

    SyncLink::remote_number

    source
    fn SyncLink::remote_number(self : SyncLink) -> Int

    SyncLink::remote_updated_at

    source
    fn SyncLink::remote_updated_at(self : SyncLink) -> Int64

    SyncLink::repo

    source
    fn SyncLink::repo(self : SyncLink) -> String

    SyncLink::serialize

    source
    fn SyncLink::serialize(self : SyncLink) -> String

    Serialize SyncLink to Git-style text format

    WorkItem

    source
    pub struct WorkItem {
      id : String
      title : String
      body : String
      author : String
      created_at : Int64
      updated_at : Int64
      state : WorkItemState
      labels : Array[String]
      assignees : Array[String]
      linked_prs : Array[String]
      linked_issues : Array[String]
      patch : WorkItemPatch?
      parent_id : String?
      blocked_by : Array[String]
      blocking : Array[String]
    }

    Unified work item view of issue and pull request

    WorkItem::assignees

    source
    fn WorkItem::assignees(self : WorkItem) -> Array[String]

    WorkItem::author

    source
    fn WorkItem::author(self : WorkItem) -> String

    WorkItem::blocked_by

    source
    fn WorkItem::blocked_by(self : WorkItem) -> Array[String]

    WorkItem::blocking

    source
    fn WorkItem::blocking(self : WorkItem) -> Array[String]

    WorkItem::body

    source
    fn WorkItem::body(self : WorkItem) -> String

    WorkItem::created_at

    source
    fn WorkItem::created_at(self : WorkItem) -> Int64

    WorkItem::id

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

    WorkItem::kind

    source
    fn WorkItem::kind(self : WorkItem) -> WorkItemKind

    WorkItem::labels

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

    WorkItem::linked_issues

    source
    fn WorkItem::linked_issues(self : WorkItem) -> Array[String]

    WorkItem::linked_prs

    source
    fn WorkItem::linked_prs(self : WorkItem) -> Array[String]

    WorkItem::new

    source
    fn WorkItem::new(id : String, title : String, body : String, author : String, created_at : Int64, updated_at : Int64, state : WorkItemState, labels? : Array[String], assignees? : Array[String], linked_prs? : Array[String], linked_issues? : Array[String], patch? : WorkItemPatch?, parent_id? : String?, blocked_by? : Array[String], blocking? : Array[String]) -> WorkItem

    WorkItem::patch

    source
    fn WorkItem::patch(self : WorkItem) -> WorkItemPatch?

    WorkItem::serialize

    source
    fn WorkItem::serialize(self : WorkItem) -> String

    Serialize WorkItem to Git-style text format

    WorkItem::state

    source
    fn WorkItem::state(self : WorkItem) -> WorkItemState

    WorkItem::title

    source
    fn WorkItem::title(self : WorkItem) -> String

    WorkItem::to_issue

    source
    fn WorkItem::to_issue(self : WorkItem) -> Issue?

    WorkItem::to_pull_request

    source
    fn WorkItem::to_pull_request(self : WorkItem) -> PullRequest?

    WorkItem::updated_at

    source
    fn WorkItem::updated_at(self : WorkItem) -> Int64

    WorkItemKind

    source
    pub(all) enum WorkItemKind {
      Issue
      PullRequest
    } derive(Eq, 
    Debug    )

    Work item kind

    WorkItemKind::to_string

    source
    fn WorkItemKind::to_string(self : WorkItemKind) -> String

    WorkItemPatch

    source
    pub struct WorkItemPatch {
      source_branch : String
      source_repo : String?
      source_ref : String?
      source_commit : 
    ObjectId
      target_branch : String
      target_commit : 
    ObjectId
      closes_issues : Array[String]
      merge_commit : 
    ObjectId    ?
    }

    Patch capability of a work item

    WorkItemPatch::closes_issues

    source
    fn WorkItemPatch::closes_issues(self : WorkItemPatch) -> Array[String]

    WorkItemPatch::merge_commit

    source

    WorkItemPatch::new

    source
    fn WorkItemPatch::new(source_branch : String, source_commit : 
    ObjectId    , target_branch : String, target_commit : 
    ObjectId    , closes_issues? : Array[String], merge_commit? : 
    ObjectId    ?, source_repo? : String?, source_ref? : String?) -> WorkItemPatch

    WorkItemPatch::source_branch

    source
    fn WorkItemPatch::source_branch(self : WorkItemPatch) -> String

    WorkItemPatch::source_commit

    source

    WorkItemPatch::source_ref

    source
    fn WorkItemPatch::source_ref(self : WorkItemPatch) -> String?

    WorkItemPatch::source_repo

    source
    fn WorkItemPatch::source_repo(self : WorkItemPatch) -> String?

    WorkItemPatch::target_branch

    source
    fn WorkItemPatch::target_branch(self : WorkItemPatch) -> String

    WorkItemPatch::target_commit

    source

    WorkItemState

    source
    pub(all) enum WorkItemState {
      Open
      Merged
      Closed
    } derive(Eq, 
    Debug    )

    Unified state of an Issue/PullRequest work item

    WorkItemState::to_issue_state

    source
    fn WorkItemState::to_issue_state(self : WorkItemState) -> IssueState?

    WorkItemState::to_pr_state

    source
    fn WorkItemState::to_pr_state(self : WorkItemState) -> PrState

    WorkItemState::to_string

    source
    fn WorkItemState::to_string(self : WorkItemState) -> String

    canonical_work_item_record_kind

    source
    fn canonical_work_item_record_kind() -> String

    claim_topic

    source
    fn claim_topic() -> String

    Topic string for claim messages.

    classify_record_trigger

    source
    fn classify_record_trigger(record : HubRecord) -> RecordTriggerClass

    compare_vector_clocks

    source
    fn compare_vector_clocks(a : Map[String, Int64], b : Map[String, Int64]) -> Int

    Compare two vector clocks. Returns 1 if a > b, -1 if b > a, 0 if concurrent.

    default_record_merge_policy

    source
    fn default_record_merge_policy() -> RecordMergePolicy

    find_remote_notes_ref

    source
    fn find_remote_notes_ref(refs : Array[(
    ObjectId    , String)]) -> (
    ObjectId    , String)

    find_upload_notes_ref

    source
    fn find_upload_notes_ref(refs : Array[(
    ObjectId    , String)]) -> (
    ObjectId    , String)?

    gh_issue_to_issue

    source
    fn gh_issue_to_issue(gh : GhIssue, existing_id? : String) -> Issue

    Convert a GitHub API issue to a local Issue

    gh_pr_to_pull_request

    source
    fn gh_pr_to_pull_request(gh : GhPullRequest, existing_id? : String) -> PullRequest

    Convert a GitHub API pull request to a local PullRequest

    hub_notes_ns_name

    source
    fn hub_notes_ns_name() -> String

    hub_notes_ref_name

    source
    fn hub_notes_ref_name() -> String

    fn is_sync_link_record_kind(kind : String) -> Bool

    is_work_item_record_kind

    source
    fn is_work_item_record_kind(kind : String) -> Bool

    issue_comment_key

    source
    fn issue_comment_key(issue_id : String, comment_id : String) -> String

    issue_comment_prefix

    source
    fn issue_comment_prefix(issue_id : String) -> String

    issue_diff_for_github

    source
    fn issue_diff_for_github(current : Issue, _link : SyncLink, gh : GhIssue) -> SyncDiff

    Compare a local Issue with a GitHub GhIssue and return a SyncDiff

    merge_notes_commits

    source

    merge_record_bytes

    source
    fn merge_record_bytes(ours : Bytes, theirs : Bytes) -> Bytes

    merge_record_bytes_with_policy

    source
    fn merge_record_bytes_with_policy(ours : Bytes, theirs : Bytes, conflict_policy : RecordMergePolicy) -> Bytes

    parse_claim_action

    source
    fn parse_claim_action(s : String) -> ClaimAction?

    parse_claim_message

    source
    fn parse_claim_message(json : Json) -> ClaimMessage?

    parse_claims_from_envelopes

    source
    fn parse_claims_from_envelopes(envelopes : Array[Json]) -> Array[ClaimMessage]

    Parse claim messages from relay poll envelopes. Each envelope has shape: { "payload": { ... }, "topic": "...", ... }

    parse_hub_record

    source
    fn parse_hub_record(text : String) -> HubRecord

    parse_iso8601_to_unix

    source
    fn parse_iso8601_to_unix(iso_str : String) -> Int64

    Parse ISO 8601 timestamp string to Unix seconds. Supports "YYYY-MM-DDThh:mm:ssZ" and "YYYY-MM-DDThh:mm:ss+00:00" formats. Returns 0 for empty or unparseable strings.

    parse_issue_comment

    source
    fn parse_issue_comment(text : String) -> IssueComment raise PrError

    Parse IssueComment from Git-style text format

    parse_legacy_issue

    source
    fn parse_legacy_issue(text : String) -> Issue raise PrError

    Parse legacy Issue payload (issue ...) from Git-style text format

    parse_legacy_pull_request

    source
    fn parse_legacy_pull_request(text : String) -> PullRequest raise PrError

    Parse legacy PullRequest payload (pr ...) from Git-style text format

    parse_note

    source
    fn parse_note(text : String) -> Note

    Parse Note from Git-style text format (with metadata)

    parse_note_plain

    source
    fn parse_note_plain(commit_id : 
    ObjectId    , text : String) -> Note

    Parse Note from plain text (Git compatible, creates minimal Note)

    parse_pr_comment

    source
    fn parse_pr_comment(text : String) -> PrComment raise PrError

    Parse PrComment from Git-style text format

    parse_pr_review

    source
    fn parse_pr_review(text : String) -> PrReview raise PrError

    Parse PrReview from Git-style text format

    parse_pr_workflow_result

    source
    fn parse_pr_workflow_result(text : String) -> PrWorkflowResult raise PrError

    parse_pr_workflow_status

    source
    fn parse_pr_workflow_status(value : String) -> PrWorkflowStatus?

    parse_record_merge_policy

    source
    fn parse_record_merge_policy(value : String) -> RecordMergePolicy?

    fn parse_sync_link(text : String) -> SyncLink raise PrError

    Parse SyncLink from Git-style text format

    parse_work_item

    source
    fn parse_work_item(text : String) -> WorkItem raise PrError

    Parse WorkItem from Git-style text format

    pr_comment_key

    source
    fn pr_comment_key(pr_id : String, comment_id : String) -> String

    pr_comment_prefix

    source
    fn pr_comment_prefix(pr_id : String) -> String

    pr_diff_for_github

    source
    fn pr_diff_for_github(current : PullRequest, _link : SyncLink, gh : GhPullRequest) -> SyncDiff

    Compare a local PullRequest with a GitHub GhPullRequest and return a SyncDiff

    pr_proposal_meta_key

    source
    fn pr_proposal_meta_key(pr_id : String) -> String

    pr_proposal_prefix

    source
    fn pr_proposal_prefix() -> String

    pr_review_key

    source
    fn pr_review_key(pr_id : String, review_id : String) -> String

    pr_review_prefix

    source
    fn pr_review_prefix(pr_id : String) -> String

    pr_workflow_key

    source
    fn pr_workflow_key(pr_id : String, task : String) -> String

    pr_workflow_prefix

    source
    fn pr_workflow_prefix(pr_id : String) -> String

    record_notify_topic

    source
    fn record_notify_topic(record : HubRecord) -> String?

    resolve_active_claims

    source
    fn resolve_active_claims(claims : Array[ClaimMessage]) -> Array[ClaimMessage]

    Resolve active claims: for each issue_id, keep only the latest action. If the latest action is Unclaim, the issue is not actively claimed.

    short_ref_name

    source
    fn short_ref_name(refname : String) -> String

    fn sync_link_key(local_id : String, provider : String) -> String

    fn sync_link_record_kind() -> String

    unix_to_iso8601

    source
    fn unix_to_iso8601(unix : Int64) -> String

    Convert Unix seconds to ISO 8601 string in UTC ("YYYY-MM-DDThh:mm:ssZ").

    work_item_meta_key

    source
    fn work_item_meta_key(work_item_id : String) -> String

    work_item_meta_prefix

    source
    fn work_item_meta_prefix() -> String

    write_object_bytes

    source
    fn write_object_bytes(fs : &
    FileSystem    , git_dir : String, id : 
    ObjectId    , compressed : Bytes) -> Unit raise 
    GitError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io