memlay 0.1.5

Repo-native, conflict-resistant shared memory and codebase navigation layer for AI coding agents
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use std::fmt;

/// Stable top-level error codes exposed in `--json` output and MCP errors (PRD ยง23).
/// Some variants are reserved by the PRD contract for paths not yet reachable
/// in this build (P1 archive workflow, index busy signaling).
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ErrorCode {
    NotAGitRepository,
    NotInitialized,
    InvalidConfig,
    InvalidRecord,
    ImmutableRecordChanged,
    SemanticConflict,
    IndexCorrupt,
    IndexBusy,
    PathOutsideRepository,
    McpProtocolError,
    AuditWriteFailed,
    TeamMemoryBehind,
    TeamMemoryUnknown,
    ChangeRecordRequired,
    DuplicateKeyConfirmationRequired,
    KeyAliasConflict,
    KeyAliasCycle,
    BackfillDraftInvalid,
    ArchivePlanMismatch,
    ArchiveRefMissing,
    P1NotImplemented,
    Internal,
}

impl ErrorCode {
    /// Every stable code, for the generated reference documentation. Kept
    /// beside the enum so additions are a one-file change; `as_str` below is
    /// match-exhaustive, so a new variant cannot be forgotten there.
    pub const ALL: &'static [ErrorCode] = &[
        ErrorCode::NotAGitRepository,
        ErrorCode::NotInitialized,
        ErrorCode::InvalidConfig,
        ErrorCode::InvalidRecord,
        ErrorCode::ImmutableRecordChanged,
        ErrorCode::SemanticConflict,
        ErrorCode::IndexCorrupt,
        ErrorCode::IndexBusy,
        ErrorCode::PathOutsideRepository,
        ErrorCode::McpProtocolError,
        ErrorCode::AuditWriteFailed,
        ErrorCode::TeamMemoryBehind,
        ErrorCode::TeamMemoryUnknown,
        ErrorCode::ChangeRecordRequired,
        ErrorCode::DuplicateKeyConfirmationRequired,
        ErrorCode::KeyAliasConflict,
        ErrorCode::KeyAliasCycle,
        ErrorCode::BackfillDraftInvalid,
        ErrorCode::ArchivePlanMismatch,
        ErrorCode::ArchiveRefMissing,
        ErrorCode::P1NotImplemented,
        ErrorCode::Internal,
    ];

    pub fn as_str(self) -> &'static str {
        match self {
            ErrorCode::NotAGitRepository => "NOT_A_GIT_REPOSITORY",
            ErrorCode::NotInitialized => "NOT_INITIALIZED",
            ErrorCode::InvalidConfig => "INVALID_CONFIG",
            ErrorCode::InvalidRecord => "INVALID_RECORD",
            ErrorCode::ImmutableRecordChanged => "IMMUTABLE_RECORD_CHANGED",
            ErrorCode::SemanticConflict => "SEMANTIC_CONFLICT",
            ErrorCode::IndexCorrupt => "INDEX_CORRUPT",
            ErrorCode::IndexBusy => "INDEX_BUSY",
            ErrorCode::PathOutsideRepository => "PATH_OUTSIDE_REPOSITORY",
            ErrorCode::McpProtocolError => "MCP_PROTOCOL_ERROR",
            ErrorCode::AuditWriteFailed => "AUDIT_WRITE_FAILED",
            ErrorCode::TeamMemoryBehind => "TEAM_MEMORY_BEHIND",
            ErrorCode::TeamMemoryUnknown => "TEAM_MEMORY_UNKNOWN",
            ErrorCode::ChangeRecordRequired => "CHANGE_RECORD_REQUIRED",
            ErrorCode::DuplicateKeyConfirmationRequired => "DUPLICATE_KEY_CONFIRMATION_REQUIRED",
            ErrorCode::KeyAliasConflict => "KEY_ALIAS_CONFLICT",
            ErrorCode::KeyAliasCycle => "KEY_ALIAS_CYCLE",
            ErrorCode::BackfillDraftInvalid => "BACKFILL_DRAFT_INVALID",
            ErrorCode::ArchivePlanMismatch => "ARCHIVE_PLAN_MISMATCH",
            ErrorCode::ArchiveRefMissing => "ARCHIVE_REF_MISSING",
            ErrorCode::P1NotImplemented => "P1_NOT_IMPLEMENTED",
            ErrorCode::Internal => "INTERNAL",
        }
    }
}

impl fmt::Display for ErrorCode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, thiserror::Error)]
#[error("{code}: {message}")]
pub struct MemlayError {
    pub code: ErrorCode,
    pub message: String,
}

impl MemlayError {
    pub fn new(code: ErrorCode, message: impl Into<String>) -> Self {
        Self {
            code,
            message: message.into(),
        }
    }
}

pub fn err(code: ErrorCode, message: impl Into<String>) -> anyhow::Error {
    anyhow::Error::new(MemlayError::new(code, message))
}

/// Extract the stable error code from an anyhow chain, defaulting to INTERNAL.
pub fn code_of(e: &anyhow::Error) -> ErrorCode {
    e.downcast_ref::<MemlayError>()
        .map(|m| m.code)
        .unwrap_or(ErrorCode::Internal)
}