373 lines
14 KiB
Rust
373 lines
14 KiB
Rust
use serde::Serialize;
|
|
use thiserror::Error;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum NetworkErrorKind {
|
|
Timeout,
|
|
ConnectionRefused,
|
|
DnsResolution,
|
|
Tls,
|
|
Other,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum ErrorCode {
|
|
ConfigNotFound,
|
|
ConfigInvalid,
|
|
GitLabAuthFailed,
|
|
GitLabNotFound,
|
|
GitLabRateLimited,
|
|
GitLabNetworkError,
|
|
DatabaseLocked,
|
|
DatabaseError,
|
|
MigrationFailed,
|
|
TokenNotSet,
|
|
TransformError,
|
|
IoError,
|
|
InternalError,
|
|
OllamaUnavailable,
|
|
OllamaModelNotFound,
|
|
EmbeddingFailed,
|
|
NotFound,
|
|
Ambiguous,
|
|
SurgicalPreflightFailed,
|
|
}
|
|
|
|
impl std::fmt::Display for ErrorCode {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let code = match self {
|
|
Self::ConfigNotFound => "CONFIG_NOT_FOUND",
|
|
Self::ConfigInvalid => "CONFIG_INVALID",
|
|
Self::GitLabAuthFailed => "GITLAB_AUTH_FAILED",
|
|
Self::GitLabNotFound => "GITLAB_NOT_FOUND",
|
|
Self::GitLabRateLimited => "GITLAB_RATE_LIMITED",
|
|
Self::GitLabNetworkError => "GITLAB_NETWORK_ERROR",
|
|
Self::DatabaseLocked => "DB_LOCKED",
|
|
Self::DatabaseError => "DB_ERROR",
|
|
Self::MigrationFailed => "MIGRATION_FAILED",
|
|
Self::TokenNotSet => "TOKEN_NOT_SET",
|
|
Self::TransformError => "TRANSFORM_ERROR",
|
|
Self::IoError => "IO_ERROR",
|
|
Self::InternalError => "INTERNAL_ERROR",
|
|
Self::OllamaUnavailable => "OLLAMA_UNAVAILABLE",
|
|
Self::OllamaModelNotFound => "OLLAMA_MODEL_NOT_FOUND",
|
|
Self::EmbeddingFailed => "EMBEDDING_FAILED",
|
|
Self::NotFound => "NOT_FOUND",
|
|
Self::Ambiguous => "AMBIGUOUS",
|
|
Self::SurgicalPreflightFailed => "SURGICAL_PREFLIGHT_FAILED",
|
|
};
|
|
write!(f, "{code}")
|
|
}
|
|
}
|
|
|
|
impl ErrorCode {
|
|
pub fn exit_code(&self) -> i32 {
|
|
match self {
|
|
Self::InternalError => 1,
|
|
Self::ConfigNotFound => 20,
|
|
Self::ConfigInvalid => 3,
|
|
Self::TokenNotSet => 4,
|
|
Self::GitLabAuthFailed => 5,
|
|
Self::GitLabNotFound => 6,
|
|
Self::GitLabRateLimited => 7,
|
|
Self::GitLabNetworkError => 8,
|
|
Self::DatabaseLocked => 9,
|
|
Self::DatabaseError => 10,
|
|
Self::MigrationFailed => 11,
|
|
Self::IoError => 12,
|
|
Self::TransformError => 13,
|
|
Self::OllamaUnavailable => 14,
|
|
Self::OllamaModelNotFound => 15,
|
|
Self::EmbeddingFailed => 16,
|
|
Self::NotFound => 17,
|
|
Self::Ambiguous => 18,
|
|
// Shares exit code 6 with GitLabNotFound — same semantic category (resource not found).
|
|
// Robot consumers distinguish via ErrorCode string, not exit code.
|
|
Self::SurgicalPreflightFailed => 6,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum LoreError {
|
|
#[error("Config file not found at {path}. Run \"lore init\" first.")]
|
|
ConfigNotFound { path: String },
|
|
|
|
#[error("Invalid config: {details}")]
|
|
ConfigInvalid { details: String },
|
|
|
|
#[error("GitLab authentication failed. Check your token has read_api scope.")]
|
|
GitLabAuthFailed,
|
|
|
|
#[error("GitLab resource not found: {resource}")]
|
|
GitLabNotFound { resource: String },
|
|
|
|
#[error("Rate limited. Retry after {retry_after}s")]
|
|
GitLabRateLimited { retry_after: u64 },
|
|
|
|
#[error("Cannot connect to GitLab at {base_url}")]
|
|
GitLabNetworkError {
|
|
base_url: String,
|
|
kind: NetworkErrorKind,
|
|
detail: Option<String>,
|
|
},
|
|
|
|
#[error(
|
|
"Another sync is running (owner: {owner}, started: {started_at}). Use --force to override if stale."
|
|
)]
|
|
DatabaseLocked { owner: String, started_at: String },
|
|
|
|
#[error("Migration {version} failed: {message}")]
|
|
MigrationFailed {
|
|
version: i32,
|
|
message: String,
|
|
#[source]
|
|
source: Option<rusqlite::Error>,
|
|
},
|
|
|
|
#[error("GitLab token not set. Run 'lore token set' or export {env_var}.")]
|
|
TokenNotSet { env_var: String },
|
|
|
|
#[error("Database error: {0}")]
|
|
Database(#[from] rusqlite::Error),
|
|
|
|
#[error("JSON error: {0}")]
|
|
Json(#[from] serde_json::Error),
|
|
|
|
#[error("IO error: {0}")]
|
|
Io(#[from] std::io::Error),
|
|
|
|
#[error("Transform error: {0}")]
|
|
Transform(#[from] crate::gitlab::transformers::issue::TransformError),
|
|
|
|
#[error("Not found: {0}")]
|
|
NotFound(String),
|
|
|
|
#[error("Ambiguous: {0}")]
|
|
Ambiguous(String),
|
|
|
|
#[error("{0}")]
|
|
Other(String),
|
|
|
|
#[error("Cannot connect to Ollama at {base_url}. Is it running?")]
|
|
OllamaUnavailable {
|
|
base_url: String,
|
|
detail: Option<String>,
|
|
},
|
|
|
|
#[error("Ollama model '{model}' not found. Run: ollama pull {model}")]
|
|
OllamaModelNotFound { model: String },
|
|
|
|
#[error("Embedding failed for document {document_id}: {reason}")]
|
|
EmbeddingFailed { document_id: i64, reason: String },
|
|
|
|
#[error("No embeddings found. Run: lore embed")]
|
|
EmbeddingsNotBuilt,
|
|
|
|
#[error("Surgical preflight failed for {entity_type} !{iid} in {project}: {reason}")]
|
|
SurgicalPreflightFailed {
|
|
entity_type: String,
|
|
iid: u64,
|
|
project: String,
|
|
reason: String,
|
|
},
|
|
}
|
|
|
|
impl LoreError {
|
|
pub fn code(&self) -> ErrorCode {
|
|
match self {
|
|
Self::ConfigNotFound { .. } => ErrorCode::ConfigNotFound,
|
|
Self::ConfigInvalid { .. } => ErrorCode::ConfigInvalid,
|
|
Self::GitLabAuthFailed => ErrorCode::GitLabAuthFailed,
|
|
Self::GitLabNotFound { .. } => ErrorCode::GitLabNotFound,
|
|
Self::GitLabRateLimited { .. } => ErrorCode::GitLabRateLimited,
|
|
Self::GitLabNetworkError { .. } => ErrorCode::GitLabNetworkError,
|
|
Self::DatabaseLocked { .. } => ErrorCode::DatabaseLocked,
|
|
Self::MigrationFailed { .. } => ErrorCode::MigrationFailed,
|
|
Self::TokenNotSet { .. } => ErrorCode::TokenNotSet,
|
|
Self::Database(e) => {
|
|
if e.sqlite_error_code() == Some(rusqlite::ErrorCode::DatabaseBusy) {
|
|
ErrorCode::DatabaseLocked
|
|
} else {
|
|
ErrorCode::DatabaseError
|
|
}
|
|
}
|
|
Self::Json(_) => ErrorCode::InternalError,
|
|
Self::Io(_) => ErrorCode::IoError,
|
|
Self::Transform(_) => ErrorCode::TransformError,
|
|
Self::NotFound(_) => ErrorCode::NotFound,
|
|
Self::Ambiguous(_) => ErrorCode::Ambiguous,
|
|
Self::Other(_) => ErrorCode::InternalError,
|
|
Self::OllamaUnavailable { .. } => ErrorCode::OllamaUnavailable,
|
|
Self::OllamaModelNotFound { .. } => ErrorCode::OllamaModelNotFound,
|
|
Self::EmbeddingFailed { .. } => ErrorCode::EmbeddingFailed,
|
|
Self::EmbeddingsNotBuilt => ErrorCode::EmbeddingFailed,
|
|
Self::SurgicalPreflightFailed { .. } => ErrorCode::SurgicalPreflightFailed,
|
|
}
|
|
}
|
|
|
|
pub fn suggestion(&self) -> Option<&'static str> {
|
|
match self {
|
|
Self::ConfigNotFound { .. } => Some(
|
|
"Run 'lore init' to set up your GitLab connection.\n\n Expected: ~/.config/lore/config.json",
|
|
),
|
|
Self::ConfigInvalid { .. } => Some(
|
|
"Check config file syntax or run 'lore init' to recreate.\n\n Example:\n lore init\n lore init --force",
|
|
),
|
|
Self::GitLabAuthFailed => Some(
|
|
"Verify token has read_api scope and is not expired.\n\n Example:\n export GITLAB_TOKEN=glpat-xxxxxxxxxxxx\n lore auth",
|
|
),
|
|
Self::GitLabNotFound { .. } => Some(
|
|
"Check the resource path exists and you have access.\n\n Example:\n lore issues -p group/project\n lore mrs -p group/project",
|
|
),
|
|
Self::GitLabRateLimited { .. } => Some("Wait and retry, or reduce request frequency"),
|
|
Self::GitLabNetworkError { .. } => Some(
|
|
"Check network connection and GitLab URL.\n\n Example:\n lore doctor\n lore auth",
|
|
),
|
|
Self::DatabaseLocked { .. } => Some(
|
|
"Wait for other sync to complete or use --force.\n\n Example:\n lore ingest --force\n lore ingest issues --force",
|
|
),
|
|
Self::MigrationFailed { .. } => Some(
|
|
"Check database file permissions and try again.\n\n Example:\n lore migrate\n lore doctor",
|
|
),
|
|
Self::TokenNotSet { .. } => Some(
|
|
"Set your token:\n\n lore token set\n\n Or export to your shell:\n\n export GITLAB_TOKEN=glpat-xxxxxxxxxxxx\n\n Your token needs the read_api scope.",
|
|
),
|
|
Self::Database(e) => {
|
|
if e.sqlite_error_code() == Some(rusqlite::ErrorCode::DatabaseBusy) {
|
|
Some(
|
|
"Another process has the database locked. Wait a moment and retry.\n\n Common causes:\n - A cron sync is running (lore cron status)\n - Another lore command is active",
|
|
)
|
|
} else {
|
|
Some("Check database file permissions.\n\n Example:\n lore doctor")
|
|
}
|
|
}
|
|
Self::NotFound(_) => {
|
|
Some("Verify the entity exists.\n\n Example:\n lore issues\n lore mrs")
|
|
}
|
|
Self::Ambiguous(_) => Some(
|
|
"Use -p to choose a specific project.\n\n Example:\n lore issues 42 -p group/project-a\n lore mrs 99 -p group/project-b",
|
|
),
|
|
Self::OllamaUnavailable { .. } => Some("Start Ollama: ollama serve"),
|
|
Self::OllamaModelNotFound { .. } => {
|
|
Some("Pull the model: ollama pull nomic-embed-text")
|
|
}
|
|
Self::EmbeddingFailed { .. } => {
|
|
Some("Check Ollama logs or retry with 'lore embed --retry-failed'")
|
|
}
|
|
Self::EmbeddingsNotBuilt => Some("Generate embeddings first: lore embed"),
|
|
Self::SurgicalPreflightFailed { .. } => Some(
|
|
"Verify the IID exists in the project and you have access.\n\n Example:\n lore issues -p <project>\n lore mrs -p <project>",
|
|
),
|
|
Self::Json(_) | Self::Io(_) | Self::Transform(_) | Self::Other(_) => None,
|
|
}
|
|
}
|
|
|
|
pub fn is_permanent_api_error(&self) -> bool {
|
|
matches!(self, Self::GitLabNotFound { .. } | Self::GitLabAuthFailed)
|
|
}
|
|
|
|
pub fn exit_code(&self) -> i32 {
|
|
self.code().exit_code()
|
|
}
|
|
|
|
pub fn actions(&self) -> Vec<&'static str> {
|
|
match self {
|
|
Self::ConfigNotFound { .. } => vec!["lore init"],
|
|
Self::ConfigInvalid { .. } => vec!["lore init --force"],
|
|
Self::GitLabAuthFailed => {
|
|
vec!["export GITLAB_TOKEN=glpat-xxx", "lore auth"]
|
|
}
|
|
Self::TokenNotSet { .. } => vec!["lore token set", "export GITLAB_TOKEN=glpat-xxx"],
|
|
Self::OllamaUnavailable { .. } => vec!["ollama serve"],
|
|
Self::OllamaModelNotFound { .. } => vec!["ollama pull nomic-embed-text"],
|
|
Self::DatabaseLocked { .. } => vec!["lore ingest --force"],
|
|
Self::Database(e)
|
|
if e.sqlite_error_code() == Some(rusqlite::ErrorCode::DatabaseBusy) =>
|
|
{
|
|
vec!["lore cron status"]
|
|
}
|
|
Self::EmbeddingsNotBuilt => vec!["lore embed"],
|
|
Self::EmbeddingFailed { .. } => vec!["lore embed --retry-failed"],
|
|
Self::MigrationFailed { .. } => vec!["lore migrate"],
|
|
Self::GitLabNetworkError { .. } => vec!["lore doctor"],
|
|
Self::SurgicalPreflightFailed { .. } => {
|
|
vec!["lore issues -p <project>", "lore mrs -p <project>"]
|
|
}
|
|
_ => vec![],
|
|
}
|
|
}
|
|
|
|
pub fn to_robot_error(&self) -> RobotError {
|
|
let actions = self.actions().into_iter().map(String::from).collect();
|
|
RobotError {
|
|
code: self.code().to_string(),
|
|
message: self.to_string(),
|
|
suggestion: self.suggestion().map(String::from),
|
|
actions,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct RobotError {
|
|
pub code: String,
|
|
pub message: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub suggestion: Option<String>,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub actions: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct RobotErrorOutput {
|
|
pub error: RobotError,
|
|
}
|
|
|
|
impl From<&LoreError> for RobotErrorOutput {
|
|
fn from(e: &LoreError) -> Self {
|
|
Self {
|
|
error: e.to_robot_error(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Result<T> = std::result::Result<T, LoreError>;
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn surgical_preflight_failed_display() {
|
|
let err = LoreError::SurgicalPreflightFailed {
|
|
entity_type: "issue".to_string(),
|
|
iid: 42,
|
|
project: "group/repo".to_string(),
|
|
reason: "not found on GitLab".to_string(),
|
|
};
|
|
let msg = err.to_string();
|
|
assert!(msg.contains("issue"), "missing entity_type: {msg}");
|
|
assert!(msg.contains("42"), "missing iid: {msg}");
|
|
assert!(msg.contains("group/repo"), "missing project: {msg}");
|
|
assert!(msg.contains("not found on GitLab"), "missing reason: {msg}");
|
|
}
|
|
|
|
#[test]
|
|
fn surgical_preflight_failed_error_code() {
|
|
let code = ErrorCode::SurgicalPreflightFailed;
|
|
assert_eq!(code.exit_code(), 6);
|
|
}
|
|
|
|
#[test]
|
|
fn surgical_preflight_failed_code_mapping() {
|
|
let err = LoreError::SurgicalPreflightFailed {
|
|
entity_type: "merge_request".to_string(),
|
|
iid: 99,
|
|
project: "ns/proj".to_string(),
|
|
reason: "404".to_string(),
|
|
};
|
|
assert_eq!(err.code(), ErrorCode::SurgicalPreflightFailed);
|
|
}
|
|
}
|