feat: improve interpreted Git error handling

Author: cst8t

src-tauri/src/git/error_interpretation.rs

@@ -168,13 +168,34 @@ fn classify_message(message: &str) -> (GitErrorCategory, f32) {
             "could not find remote ref",
             "upstream is gone",
             "remote ref does not exist",
+            "no such ref",
+            "no such remote ref",
         ],
     ) || (lower.contains("remote branch")
         && contains_any(&lower, &["not found", "does not exist", "missing"]))
     {
         return (GitErrorCategory::UpstreamMissing, 0.9);
     }
 
+    if contains_any(
+        &lower,
+        &[
+            "could not resolve host",
+            "failed to connect",
+            "connection timed out",
+            "network is unreachable",
+            "connection reset",
+            "operation timed out",
+            "temporary failure in name resolution",
+            "name or service not known",
+            "could not resolve hostname",
+            "unable to access",
+            "couldn't connect to server",
+        ],
+    ) {
+        return (GitErrorCategory::Network, 0.85);
+    }
+
     if contains_any(
         &lower,
         &[
@@ -192,22 +213,6 @@ fn classify_message(message: &str) -> (GitErrorCategory, f32) {
         return (GitErrorCategory::Auth, 0.9);
     }
 
-    if contains_any(
-        &lower,
-        &[
-            "could not resolve host",
-            "failed to connect",
-            "connection timed out",
-            "network is unreachable",
-            "connection reset",
-            "operation timed out",
-            "unable to access",
-            "couldn't connect to server",
-        ],
-    ) {
-        return (GitErrorCategory::Network, 0.85);
-    }
-
     if contains_any(
         &lower,
         &[
@@ -330,6 +335,21 @@ mod tests {
     #[derive(Debug)]
     struct FakeTransportError;
 
+    #[derive(Debug)]
+    struct FakeAuthError;
+
+    #[derive(Debug)]
+    struct FakeLockTransactionError;
+
+    #[derive(Debug)]
+    struct FakeConfigError;
+
+    #[derive(Debug)]
+    struct FakeReferenceRevisionError;
+
+    #[derive(Debug)]
+    struct FakeFallbackError(&'static str);
+
     impl std::fmt::Display for FakeTransportError {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(f, "handshake failed")
@@ -338,6 +358,46 @@ mod tests {
 
     impl Error for FakeTransportError {}
 
+    impl std::fmt::Display for FakeAuthError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "credential lookup failed")
+        }
+    }
+
+    impl Error for FakeAuthError {}
+
+    impl std::fmt::Display for FakeLockTransactionError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "transaction could not write lock")
+        }
+    }
+
+    impl Error for FakeLockTransactionError {}
+
+    impl std::fmt::Display for FakeConfigError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "config value is invalid")
+        }
+    }
+
+    impl Error for FakeConfigError {}
+
+    impl std::fmt::Display for FakeReferenceRevisionError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "revision could not be resolved")
+        }
+    }
+
+    impl Error for FakeReferenceRevisionError {}
+
+    impl std::fmt::Display for FakeFallbackError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{}", self.0)
+        }
+    }
+
+    impl Error for FakeFallbackError {}
+
     #[test]
     fn cli_non_fast_forward_wins_before_broader_rejected_text() {
         let interpreted = interpret_cli_error(
@@ -383,6 +443,34 @@ mod tests {
         assert_eq!(network.category, GitErrorCategory::Network);
     }
 
+    #[test]
+    fn cli_upstream_missing_matches_common_remote_ref_messages() {
+        let interpreted = interpret_cli_error(
+            Some("push"),
+            "fatal: couldn't find remote ref refs/heads/main\nerror: no such ref was fetched",
+            Some(128),
+        );
+
+        assert_eq!(interpreted.category, GitErrorCategory::UpstreamMissing);
+        assert!(interpreted.confidence >= 0.85);
+    }
+
+    #[test]
+    fn cli_dns_style_output_maps_to_network() {
+        let interpreted = interpret_cli_error(
+            Some("fetch"),
+            "ssh: Could not resolve hostname example.invalid: Name or service not known\nfatal: Could not read from remote repository.",
+            Some(128),
+        );
+
+        assert_eq!(interpreted.category, GitErrorCategory::Network);
+        assert!(
+            interpreted
+                .suggested_actions
+                .contains(&"check-network".to_string())
+        );
+    }
+
     #[test]
     fn cli_conflict_state_maps_to_sequencer_actions() {
         let interpreted = interpret_cli_error(
@@ -433,6 +521,48 @@ mod tests {
         assert_eq!(interpreted.backend, GitBackendSource::Gix);
     }
 
+    #[test]
+    fn gix_typed_auth_family_maps_to_auth() {
+        let err = FakeAuthError;
+        let interpreted = interpret_gix_error(Some("fetch"), &err);
+
+        assert_eq!(interpreted.category, GitErrorCategory::Auth);
+        assert_eq!(interpreted.backend, GitBackendSource::Gix);
+    }
+
+    #[test]
+    fn gix_typed_lock_transaction_family_maps_to_index_lock() {
+        let err = FakeLockTransactionError;
+        let interpreted = interpret_gix_error(Some("commit"), &err);
+
+        assert_eq!(interpreted.category, GitErrorCategory::IndexLock);
+    }
+
+    #[test]
+    fn gix_typed_config_family_maps_to_repo_state() {
+        let err = FakeConfigError;
+        let interpreted = interpret_gix_error(Some("status"), &err);
+
+        assert_eq!(interpreted.category, GitErrorCategory::RepoState);
+    }
+
+    #[test]
+    fn gix_typed_reference_revision_family_maps_to_repo_state() {
+        let err = FakeReferenceRevisionError;
+        let interpreted = interpret_gix_error(Some("log"), &err);
+
+        assert_eq!(interpreted.category, GitErrorCategory::RepoState);
+    }
+
+    #[test]
+    fn gix_fallback_message_uses_other_for_unknowns() {
+        let err = FakeFallbackError("unexpected internal state");
+        let interpreted = interpret_gix_error(Some("status"), &err);
+
+        assert_eq!(interpreted.category, GitErrorCategory::Other);
+        assert!(interpreted.confidence < 0.5);
+    }
+
     #[test]
     fn gix_opaque_message_uses_lower_confidence_heuristics() {
         let err = std::io::Error::other("could not lock config file");

src-tauri/tests/git.rs

@@ -4,12 +4,13 @@ use std::process::Command;
 use tempfile::TempDir;
 
 use gitmun_lib::git::cli::CliGitHandler;
+use gitmun_lib::git::error_interpretation::GitErrorCategory;
 use gitmun_lib::git::gix_handler::GixGitHandler;
 use gitmun_lib::git::handler::GitOperationHandler;
 use gitmun_lib::git::types::{
     CommitDetailsRequest, CommitHistoryRequest, CommitLogScope, CommitRequest, CreateBranchRequest,
-    FileRequest, PushRequest, RepoRequest, SetBranchUpstreamRequest, StageFilesRequest,
-    SubmoduleActionRequest, SubmoduleState,
+    FileRequest, PushFailureKind, PushRequest, RepoRequest, SetBranchUpstreamRequest,
+    StageFilesRequest, SubmoduleActionRequest, SubmoduleState,
 };
 
 fn init_repo() -> TempDir {
@@ -947,11 +948,18 @@ fn push_changes_classifies_non_fast_forward() {
         .expect("push_changes");
 
     assert!(!result.success);
+    let interpreted = result.interpreted_error.expect("interpreted error");
+    assert_eq!(interpreted.category, GitErrorCategory::NonFastForward);
+    assert!(interpreted.confidence >= 0.9);
+    assert!(
+        result
+            .output
+            .as_deref()
+            .is_some_and(|output| output.contains("[rejected]") || output.contains("fetch first")),
+        "raw Git output is preserved"
+    );
     let rejection = result.rejection.expect("push rejection");
-    assert!(matches!(
-        rejection.kind,
-        gitmun_lib::git::types::PushFailureKind::NonFastForward
-    ));
+    assert!(matches!(rejection.kind, PushFailureKind::NonFastForward));
 }
 
 #[test]
@@ -1092,11 +1100,89 @@ fn push_without_upstream_returns_publish_guidance() {
         .expect("push_changes");
 
     assert!(!result.success);
+    let interpreted = result.interpreted_error.expect("interpreted error");
+    assert_eq!(interpreted.category, GitErrorCategory::NoUpstream);
+    assert_eq!(interpreted.suggested_actions, vec!["set-upstream"]);
+    assert!(
+        result
+            .output
+            .as_deref()
+            .is_some_and(|output| output.contains("no upstream branch")),
+        "raw Git output is preserved"
+    );
     let rejection = result.rejection.expect("push rejection");
-    assert!(matches!(
-        rejection.kind,
-        gitmun_lib::git::types::PushFailureKind::NoUpstream
-    ));
+    assert!(matches!(rejection.kind, PushFailureKind::NoUpstream));
+}
+
+#[test]
+fn push_with_mismatched_upstream_returns_repair_guidance() {
+    let (_remote, local) = init_remote_with_clone();
+    git(
+        local.path(),
+        &["config", "branch.main.merge", "refs/heads/missing"],
+    );
+
+    let result = handler()
+        .push_changes(&push_request(&local))
+        .expect("push_changes");
+
+    assert!(!result.success);
+    let interpreted = result.interpreted_error.expect("interpreted error");
+    assert_eq!(interpreted.category, GitErrorCategory::UpstreamMissing);
+    assert!(
+        interpreted
+            .suggested_actions
+            .contains(&"repair-upstream".to_string())
+    );
+    let rejection = result.rejection.expect("push rejection");
+    assert!(matches!(rejection.kind, PushFailureKind::UpstreamMissing));
+    assert!(
+        result
+            .output
+            .as_deref()
+            .is_some_and(|output| output.contains("upstream branch")),
+        "raw Git output is preserved"
+    );
+}
+
+#[test]
+fn push_to_unresolvable_remote_returns_network_guidance() {
+    let (_remote, local) = init_remote_with_clone();
+    write_file(local.path(), "network.txt", "network");
+    git(local.path(), &["add", "network.txt"]);
+    git(local.path(), &["commit", "-m", "network"]);
+    git(
+        local.path(),
+        &[
+            "config",
+            "core.sshCommand",
+            "sh -c 'echo \"ssh: Could not resolve hostname example.invalid: Name or service not known\" >&2; exit 255'",
+        ],
+    );
+    git(
+        local.path(),
+        &[
+            "remote",
+            "set-url",
+            "origin",
+            "ssh://git@example.invalid/repo.git",
+        ],
+    );
+
+    let result = handler()
+        .push_changes(&push_request(&local))
+        .expect("push_changes");
+
+    assert!(!result.success);
+    let interpreted = result.interpreted_error.expect("interpreted error");
+    assert_eq!(interpreted.category, GitErrorCategory::Network);
+    assert!(
+        result
+            .output
+            .as_deref()
+            .is_some_and(|output| output.contains("Could not resolve hostname")),
+        "raw Git output is preserved"
+    );
 }
 
 #[test]

src/components/ProjectView.tsx

@@ -58,6 +58,7 @@ import type { ResultLogEntry } from "../utils/resultLog";
 import { appendResultLog } from "../utils/resultLog";
 import type { PlatformType } from "../hooks/usePlatform";
 import type { ToastType } from "../hooks/useToast";
+import { buildPushFailureDisplay } from "../utils/gitErrorDisplay";
 import { getRemoteActionState } from "../utils/remoteActionState";
 
 // Tracks whether the no-diff-tool warning has already been shown this session
@@ -723,24 +724,15 @@ export function ProjectView({
   }, [runPullWithStrategy]);
 
   const handlePushFailure = useCallback((result: Awaited<ReturnType<typeof api.pushChanges>>) => {
-    let interpretedMessage: string | null = null;
-    if (result.interpretedError) {
-      const actions = result.interpretedError.suggestedActions
-        .slice(0, 3)
-        .map((action) => tGitAdvice(`actions.${action}`, { defaultValue: action }))
-        .join(", ");
-      interpretedMessage = actions
-        ? tGitAdvice("withActions", { summary: result.interpretedError.summary, actions })
-        : result.interpretedError.summary;
-    }
-    if (result.rejection && ["non-fast-forward", "no-upstream", "upstream-missing"].includes(result.rejection.kind)) {
-      setPushRejectionAnalysis(result.rejection);
-      appendResultLog("error", interpretedMessage ?? result.rejection.message, result.backendUsed);
+    const display = buildPushFailureDisplay(result, tGitAdvice);
+    if (display.dialogRejection) {
+      setPushRejectionAnalysis(display.dialogRejection);
+      appendResultLog("error", display.logMessage, result.backendUsed, undefined, display.logDetails);
       return;
     }
 
-    showToast(interpretedMessage ?? result.message, "error");
-    appendResultLog("error", result.output?.trim() || result.message, result.backendUsed);
+    showToast(display.toastMessage ?? result.message, "error");
+    appendResultLog("error", display.logMessage, result.backendUsed, undefined, display.logDetails);
   }, [showToast, tGitAdvice]);
 
   const runPushRequest = useCallback(async (