setup: Add git-init guidance for non-git hook installs

Detect non-git repositories before hook setup work so `sce setup --hooks`
  fails with actionable remediation instead of surfacing raw git errors.

Author: davidabram

cli/src/app.rs

@@ -613,6 +613,19 @@ fn dispatch(command: &Command) -> Result<String, ClassifiedError> {
                 .context("Failed to determine current directory")
                 .map_err(|error| ClassifiedError::runtime(error.to_string()))?;
 
+            let preflight_hooks_repository = if request.install_hooks {
+                let repository_root = request
+                    .hooks_repo_path
+                    .as_deref()
+                    .unwrap_or(current_dir.as_path());
+                Some(
+                    services::setup::prepare_setup_hooks_repository(repository_root)
+                        .map_err(|error| ClassifiedError::runtime(error.to_string()))?,
+                )
+            } else {
+                None
+            };
+
             let mut sections = Vec::new();
 
             if let Some(mode) = request.config_mode {
@@ -636,10 +649,9 @@ fn dispatch(command: &Command) -> Result<String, ClassifiedError> {
             }
 
             if request.install_hooks {
-                let repository_root = request
-                    .hooks_repo_path
+                let repository_root = preflight_hooks_repository
                     .as_deref()
-                    .unwrap_or(current_dir.as_path());
+                    .expect("hook repository preflight should exist when install_hooks is true");
                 let hooks_message = services::setup::run_setup_hooks(repository_root)
                     .map_err(|error| ClassifiedError::runtime(error.to_string()))?;
                 sections.push(hooks_message);

cli/src/services/setup.rs

@@ -181,12 +181,16 @@ pub fn run_setup_for_mode(repository_root: &Path, mode: SetupMode) -> Result<Str
 }
 
 pub fn run_setup_hooks(repository_root: &Path) -> Result<String> {
-    let normalized_repository_root = normalize_user_repository_path(repository_root)?;
-    let outcome = install_required_git_hooks(&normalized_repository_root)
+    let outcome = install_required_git_hooks(repository_root)
         .context("Hook setup failed while installing required git hooks")?;
     Ok(format_required_hook_install_success_message(&outcome))
 }
 
+pub fn prepare_setup_hooks_repository(repository_root: &Path) -> Result<PathBuf> {
+    let normalized_repository_root = normalize_user_repository_path(repository_root)?;
+    resolve_git_repository_root(&normalized_repository_root)
+}
+
 fn normalize_user_repository_path(repository_root: &Path) -> Result<PathBuf> {
     if repository_root.as_os_str().is_empty() {
         bail!("Option '--repo' must not be empty. Try: pass a path to an existing git repository.");
@@ -325,17 +329,31 @@ pub struct RequiredHooksInstallOutcome {
 }
 
 pub fn install_required_git_hooks(repository_root: &Path) -> Result<RequiredHooksInstallOutcome> {
-    install_required_git_hooks_with_rename(repository_root, |from, to| fs::rename(from, to))
+    let resolved_repository_root = prepare_setup_hooks_repository(repository_root)?;
+    install_required_git_hooks_in_resolved_repository(&resolved_repository_root, |from, to| {
+        fs::rename(from, to)
+    })
 }
 
+#[cfg_attr(not(test), allow(dead_code))]
 fn install_required_git_hooks_with_rename<F>(
     repository_root: &Path,
     mut rename_fn: F,
 ) -> Result<RequiredHooksInstallOutcome>
 where
     F: FnMut(&Path, &Path) -> io::Result<()>,
 {
-    let resolved_repository_root = resolve_git_repository_root(repository_root)?;
+    let resolved_repository_root = prepare_setup_hooks_repository(repository_root)?;
+    install_required_git_hooks_in_resolved_repository(&resolved_repository_root, &mut rename_fn)
+}
+
+fn install_required_git_hooks_in_resolved_repository<F>(
+    resolved_repository_root: &Path,
+    mut rename_fn: F,
+) -> Result<RequiredHooksInstallOutcome>
+where
+    F: FnMut(&Path, &Path) -> io::Result<()>,
+{
     ensure_directory_is_writable(&resolved_repository_root, "repository root")?;
     let hooks_directory = resolve_git_hooks_directory(&resolved_repository_root)?;
     fs::create_dir_all(&hooks_directory).with_context(|| {
@@ -354,7 +372,7 @@ where
     }
 
     Ok(RequiredHooksInstallOutcome {
-        repository_root: resolved_repository_root,
+        repository_root: resolved_repository_root.to_path_buf(),
         hooks_directory,
         hook_results,
     })
@@ -515,10 +533,27 @@ fn resolve_git_repository_root(repository_root: &Path) -> Result<PathBuf> {
         repository_root,
         &["rev-parse", "--show-toplevel"],
         "Failed to resolve repository root. Ensure '--repo' points to an accessible git repository.",
-    )?;
+    )
+    .map_err(|error| map_setup_non_git_repository_error(repository_root, error))?;
     Ok(PathBuf::from(repository_root_output))
 }
 
+fn map_setup_non_git_repository_error(
+    repository_root: &Path,
+    error: anyhow::Error,
+) -> anyhow::Error {
+    let message = error.to_string();
+    if message.contains("not a git repository") {
+        anyhow::anyhow!(
+            "Directory '{}' is not a git repository. Try: run 'git init' in '{}', then rerun 'sce setup'.",
+            repository_root.display(),
+            repository_root.display()
+        )
+    } else {
+        error
+    }
+}
+
 fn resolve_git_hooks_directory(repository_root: &Path) -> Result<PathBuf> {
     let hooks_directory_output = run_git_command_in_directory(
         repository_root,

cli/src/services/setup/tests.rs

@@ -115,9 +115,8 @@ fn run_setup_hooks_reports_per_hook_statuses() -> Result<()> {
 fn run_setup_hooks_rejects_missing_repo_path() {
     let missing_path = PathBuf::from("/definitely/missing/sce-test-repo");
     let error = run_setup_hooks(&missing_path).expect_err("missing repo path should fail");
-    assert!(error
-        .to_string()
-        .contains("Failed to resolve repository path"));
+    let message = format!("{error:#}");
+    assert!(message.contains("Failed to resolve repository path"));
 }
 
 #[test]
@@ -127,7 +126,21 @@ fn run_setup_hooks_rejects_file_repo_path() -> Result<()> {
     fs::write(&file_path, b"not a repo")?;
 
     let error = run_setup_hooks(&file_path).expect_err("file path should fail");
-    assert!(error.to_string().contains("is not a directory"));
+    let message = format!("{error:#}");
+    assert!(message.contains("is not a directory"));
+
+    Ok(())
+}
+
+#[test]
+fn run_setup_hooks_rejects_non_git_directory_with_git_init_guidance() -> Result<()> {
+    let temp = TestTempDir::new("sce-setup-hook-install-tests")?;
+
+    let error = run_setup_hooks(temp.path()).expect_err("non-git directory should fail");
+    let message = format!("{error:#}");
+    assert!(message.contains("is not a git repository"));
+    assert!(message.contains("git init"));
+    assert!(message.contains("rerun 'sce setup'"));
 
     Ok(())
 }

cli/tests/setup_integration.rs

@@ -365,6 +365,77 @@ fn setup_fail_repo_missing() -> TestResult<()> {
     Ok(())
 }
 
+#[test]
+fn setup_fail_hooks_in_non_git_current_directory() -> TestResult<()> {
+    let harness = SetupIntegrationHarness::new("sce-setup-failure-contracts")?;
+
+    let result = harness.run_sce(["setup", "--hooks"])?;
+
+    assert_eq!(
+        result.status.code(),
+        Some(4),
+        "setup --hooks in a non-git directory should exit with runtime_failure code 4\nstdout:\n{}\nstderr:\n{}",
+        result.stdout,
+        result.stderr
+    );
+
+    assert!(
+        result.stderr.contains("is not a git repository"),
+        "stderr should explain the current directory is not a git repository\nstderr:\n{}",
+        result.stderr
+    );
+    assert!(
+        result.stderr.contains("git init"),
+        "stderr should include git init guidance\nstderr:\n{}",
+        result.stderr
+    );
+    assert!(
+        result.stderr.contains("rerun 'sce setup'"),
+        "stderr should tell the user to rerun sce setup\nstderr:\n{}",
+        result.stderr
+    );
+
+    Ok(())
+}
+
+#[test]
+fn setup_fail_hooks_repo_flag_in_non_git_directory() -> TestResult<()> {
+    let harness = SetupIntegrationHarness::new("sce-setup-failure-contracts")?;
+
+    let result = harness.run_sce([
+        "setup",
+        "--hooks",
+        "--repo",
+        harness.repo_root().to_str().unwrap(),
+    ])?;
+
+    assert_eq!(
+        result.status.code(),
+        Some(4),
+        "setup --hooks --repo <non-git-dir> should exit with runtime_failure code 4\nstdout:\n{}\nstderr:\n{}",
+        result.stdout,
+        result.stderr
+    );
+
+    assert!(
+        result.stderr.contains("is not a git repository"),
+        "stderr should explain the supplied path is not a git repository\nstderr:\n{}",
+        result.stderr
+    );
+    assert!(
+        result.stderr.contains("git init"),
+        "stderr should include git init guidance\nstderr:\n{}",
+        result.stderr
+    );
+    assert!(
+        result.stderr.contains("rerun 'sce setup'"),
+        "stderr should tell the user to rerun sce setup\nstderr:\n{}",
+        result.stderr
+    );
+
+    Ok(())
+}
+
 #[test]
 fn setup_fail_repo_without_hooks() -> TestResult<()> {
     let harness = SetupIntegrationHarness::new("sce-setup-failure-contracts")?;