monochromatic-git-policy-cli 0.5.33

Repository-owned Git policy wrapper: forwards Git commands and checks commits against configured policies.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! What:
//!  Copying the ignored state of a linked worktree into a new one,
//!  with staging,
//!  journal and recovery.
//! Why:
//!  The copy is a transaction of its own with many small steps.
//!
//! In TS you'd write (pseudocode):
//! ```ts
//! // worktree_copying/index.ts: one `export * from './file'` per module below.
//! ```

/// The one failure type of the linked-worktree ignored-state copy and its diagnostics.
pub mod worktree_copy_error;

/// Which linked worktrees a worktree-creating Git command registered, before and after it ran.
pub mod worktree_copy_registry;

/// The ignored source paths a linked-worktree copy selects, and the path validation every selection passes.
pub mod worktree_copy_selection;

/// What a copy from a main checkout leaves out: caches, optionally run records, and other checkouts.
pub mod worktree_copy_prune;

/// The deterministic parent-first manifest of a copy, and the mode application to a staged copy.
pub mod worktree_copy_manifest;

/// Exact comparison of manifest entries against the filesystem, and the source stability check after staging.
pub mod worktree_copy_compare;

/// The private, validated stage of one source's ignored state beside a destination worktree.
pub mod worktree_copy_stage;

/// The exclusive creation of one destination entry from the stage, and the identity captured after it.
#[cfg(unix)]
pub mod worktree_copy_install_entry;

/// Installation of a validated stage into a new worktree, with preflight, batches and rollback on failure.
#[cfg(unix)]
pub mod worktree_copy_install;

/// Removal of the paths a failed installation created, only where their identity and content still prove them cli-git's own.
#[cfg(unix)]
pub mod worktree_copy_rollback;

/// The durable journal of one copy: exact encoding, strict validation, private storage and removal.
#[cfg(unix)]
pub mod worktree_copy_journal;

/// The durable claim on a stage container's name, and the removal of stages an interrupted copy left behind.
#[cfg(unix)]
pub mod worktree_copy_stage_claim;

/// The append-only install log of one stage: per-batch intents and creations, with resumption.
#[cfg(unix)]
pub mod worktree_copy_install_log;

/// One journaled installation to an end, resumption from the log, and synchronization of a created worktree.
#[cfg(unix)]
pub mod worktree_copy_transaction;

/// The process that owns one item of a copy transaction, written into the item's name, and the proof that it still runs.
#[cfg(unix)]
pub mod worktree_copy_owner;

/// Recovery of interrupted copies: registration checks, discards with notices, resumption, and the pending check.
#[cfg(unix)]
pub mod worktree_copy_recovery;

/// The linked-worktree ignored-state copy around one forwarded Git invocation: the integrator's entry point.
#[cfg(unix)]
pub mod worktree_copy;

/// Which forwarded invocations the copy applies to, and the child run that performs it.
pub mod worktree_copy_forward;