fix: improve git repository path recognition

unhappychoice · claude · unhappychoice · commit c723f8c23519 · 2025-08-30T17:20:09.000+09:00
- Add support for ssh://git@github.com/ URL format parsing - Implement git repository root detection for subdirectories - Fix relative path handling with path canonicalization - Add git repository info display on title screen - Support git info extraction from any subdirectory within a repository 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/src/extractor/git_info.rs b/src/extractor/git_info.rs
@@ -0,0 +1,174 @@
+use std::path::Path;
+use std::process::Command;
+use serde::{Deserialize, Serialize};
+use crate::Result;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct GitRepositoryInfo {
+    pub user_name: String,
+    pub repository_name: String,
+    pub remote_url: String,
+    pub branch: Option<String>,
+    pub commit_hash: Option<String>,
+    pub is_dirty: bool,
+}
+
+pub struct GitInfoExtractor;
+
+impl GitInfoExtractor {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn extract_git_info(repo_path: &Path) -> Result<Option<GitRepositoryInfo>> {
+        // Canonicalize the path to handle relative paths like ../../
+        let canonical_path = match repo_path.canonicalize() {
+            Ok(path) => path,
+            Err(_) => {
+                // If canonicalization fails, the path might not exist
+                return Ok(None);
+            }
+        };
+        
+        // Find git repository root (may be parent directory)
+        let git_root = match Self::find_git_repository_root(&canonical_path) {
+            Some(root) => root,
+            None => return Ok(None),
+        };
+
+        let remote_url = Self::get_remote_url(&git_root)?;
+        if let Some((user_name, repository_name)) = Self::parse_remote_url(&remote_url) {
+            let branch = Self::get_current_branch(&git_root).ok();
+            let commit_hash = Self::get_current_commit_hash(&git_root).ok();
+            let is_dirty = Self::is_working_directory_dirty(&git_root).unwrap_or(false);
+
+            Ok(Some(GitRepositoryInfo {
+                user_name,
+                repository_name,
+                remote_url,
+                branch,
+                commit_hash,
+                is_dirty,
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn find_git_repository_root(start_path: &Path) -> Option<std::path::PathBuf> {
+        let mut current_path = start_path;
+        
+        loop {
+            let git_dir = current_path.join(".git");
+            if git_dir.exists() {
+                return Some(current_path.to_path_buf());
+            }
+            
+            // Move to parent directory
+            match current_path.parent() {
+                Some(parent) => current_path = parent,
+                None => return None, // Reached root directory without finding .git
+            }
+        }
+    }
+
+    #[allow(dead_code)]
+    fn is_git_repository(repo_path: &Path) -> bool {
+        let git_dir = repo_path.join(".git");
+        git_dir.exists()
+    }
+
+    fn get_remote_url(repo_path: &Path) -> Result<String> {
+        let output = Command::new("git")
+            .current_dir(repo_path)
+            .args(["remote", "get-url", "origin"])
+            .output()
+            .map_err(|e| crate::GitTypeError::IoError(e))?;
+
+        if !output.status.success() {
+            return Err(crate::GitTypeError::ExtractionFailed("Failed to get remote URL".to_string()));
+        }
+
+        let url = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(url)
+    }
+
+    fn parse_remote_url(url: &str) -> Option<(String, String)> {
+        // Handle HTTPS URLs like https://github.com/user/repo.git
+        if url.starts_with("https://github.com/") {
+            let path = url.strip_prefix("https://github.com/")?;
+            let path = path.strip_suffix(".git").unwrap_or(path);
+            let parts: Vec<&str> = path.split('/').collect();
+            if parts.len() == 2 {
+                return Some((parts[0].to_string(), parts[1].to_string()));
+            }
+        }
+        
+        // Handle SSH URLs like git@github.com:user/repo.git
+        if url.starts_with("git@github.com:") {
+            let path = url.strip_prefix("git@github.com:")?;
+            let path = path.strip_suffix(".git").unwrap_or(path);
+            let parts: Vec<&str> = path.split('/').collect();
+            if parts.len() == 2 {
+                return Some((parts[0].to_string(), parts[1].to_string()));
+            }
+        }
+        
+        // Handle SSH URLs like ssh://git@github.com/user/repo.git or ssh://git@github.com/user/repo
+        if url.starts_with("ssh://git@github.com/") {
+            let path = url.strip_prefix("ssh://git@github.com/")?;
+            let path = path.strip_suffix(".git").unwrap_or(path);
+            let parts: Vec<&str> = path.split('/').collect();
+            if parts.len() == 2 {
+                return Some((parts[0].to_string(), parts[1].to_string()));
+            }
+        }
+
+        None
+    }
+
+    fn get_current_branch(repo_path: &Path) -> Result<String> {
+        let output = Command::new("git")
+            .current_dir(repo_path)
+            .args(["branch", "--show-current"])
+            .output()
+            .map_err(|e| crate::GitTypeError::IoError(e))?;
+
+        if !output.status.success() {
+            return Err(crate::GitTypeError::ExtractionFailed("Failed to get current branch".to_string()));
+        }
+
+        let branch = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(branch)
+    }
+
+    fn get_current_commit_hash(repo_path: &Path) -> Result<String> {
+        let output = Command::new("git")
+            .current_dir(repo_path)
+            .args(["rev-parse", "HEAD"])
+            .output()
+            .map_err(|e| crate::GitTypeError::IoError(e))?;
+
+        if !output.status.success() {
+            return Err(crate::GitTypeError::ExtractionFailed("Failed to get current commit hash".to_string()));
+        }
+
+        let hash = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(hash)
+    }
+
+    fn is_working_directory_dirty(repo_path: &Path) -> Result<bool> {
+        let output = Command::new("git")
+            .current_dir(repo_path)
+            .args(["status", "--porcelain"])
+            .output()
+            .map_err(|e| crate::GitTypeError::IoError(e))?;
+
+        if !output.status.success() {
+            return Err(crate::GitTypeError::ExtractionFailed("Failed to check working directory status".to_string()));
+        }
+
+        let status = String::from_utf8_lossy(&output.stdout);
+        Ok(!status.trim().is_empty())
+    }
+}
diff --git a/src/extractor/mod.rs b/src/extractor/mod.rs
@@ -1,6 +1,7 @@
 pub mod centered_progress;
 pub mod challenge_converter;
 pub mod chunk;
+pub mod git_info;
 pub mod language;
 pub mod parser;
 pub mod progress;
@@ -9,6 +10,7 @@ pub mod repository_loader;
 pub use centered_progress::CenteredProgressReporter;
 pub use challenge_converter::ChallengeConverter;
 pub use chunk::{CodeChunk, ChunkType};
+pub use git_info::{GitInfoExtractor, GitRepositoryInfo};
 pub use language::Language;
 pub use parser::{CodeExtractor, ExtractionOptions};
 pub use progress::{ConsoleProgressReporter, NoOpProgressReporter, ProgressReporter};
diff --git a/src/extractor/repository_loader.rs b/src/extractor/repository_loader.rs
@@ -1,11 +1,12 @@
 use std::path::Path;
 use crate::game::Challenge;
 use crate::{Result, GitTypeError};
-use super::{CodeExtractor, ExtractionOptions, ChallengeConverter, ProgressReporter, NoOpProgressReporter};
+use super::{CodeExtractor, ExtractionOptions, ChallengeConverter, ProgressReporter, NoOpProgressReporter, GitInfoExtractor, GitRepositoryInfo};
 
 pub struct RepositoryLoader {
     extractor: CodeExtractor,
     converter: ChallengeConverter,
+    git_info: Option<GitRepositoryInfo>,
 }
 
 impl RepositoryLoader {
@@ -16,6 +17,7 @@ impl RepositoryLoader {
         Ok(Self {
             extractor,
             converter,
+            git_info: None,
         })
     }
 
@@ -37,6 +39,9 @@ impl RepositoryLoader {
             return Err(GitTypeError::RepositoryNotFound(repo_path.to_path_buf()));
         }
 
+        // Extract git information
+        self.git_info = GitInfoExtractor::extract_git_info(repo_path)?;
+
         let extraction_options = options.unwrap_or_default();
         let chunks = self.extractor.extract_chunks_with_progress(repo_path, extraction_options, progress)?;
         
@@ -134,4 +139,9 @@ impl RepositoryLoader {
         
         Ok(zen_challenges)
     }
+
+    pub fn get_git_info(&self) -> &Option<GitRepositoryInfo> {
+        &self.git_info
+    }
+
 }
diff --git a/src/game/screens/title_screen.rs b/src/game/screens/title_screen.rs
@@ -1,5 +1,6 @@
 use crate::Result;
 use crate::game::stage_builder::DifficultyLevel;
+use crate::extractor::GitRepositoryInfo;
 use crossterm::{
     cursor::MoveTo,
     event::{self, Event, KeyCode, KeyModifiers},
@@ -24,6 +25,10 @@ impl TitleScreen {
     }
     
     pub fn show_with_challenge_counts(challenge_counts: &[usize; 5]) -> Result<TitleAction> {
+        Self::show_with_challenge_counts_and_git_info(challenge_counts, None)
+    }
+    
+    pub fn show_with_challenge_counts_and_git_info(challenge_counts: &[usize; 5], git_info: Option<&GitRepositoryInfo>) -> Result<TitleAction> {
         let mut selected_difficulty = 1; // Start with Normal (index 1)
         let difficulties = [
             ("Easy", DifficultyLevel::Easy),
@@ -41,7 +46,7 @@ impl TitleScreen {
         let center_col = terminal_width / 2;
 
         // Draw static elements once
-        Self::draw_static_elements(&mut stdout, center_row, center_col)?;
+        Self::draw_static_elements(&mut stdout, center_row, center_col, git_info)?;
         
         let mut last_difficulty = selected_difficulty;
         // Draw initial difficulty selection
@@ -84,7 +89,7 @@ impl TitleScreen {
         }
     }
 
-    fn draw_static_elements(stdout: &mut std::io::Stdout, center_row: u16, center_col: u16) -> Result<()> {
+    fn draw_static_elements(stdout: &mut std::io::Stdout, center_row: u16, center_col: u16, git_info: Option<&GitRepositoryInfo>) -> Result<()> {
         // ASCII logo lines
         let logo_lines = vec![
             "─╔═══╗─╔══╗─╔════╗────╔════╗─╔╗──╔╗─╔═══╗─╔═══╗─",
@@ -129,6 +134,9 @@ impl TitleScreen {
         execute!(stdout, Print("[ESC] Quit"))?;
         execute!(stdout, ResetColor)?;
 
+        // Display git info at bottom
+        Self::draw_git_info(stdout, git_info)?;
+
         Ok(())
     }
 
@@ -190,4 +198,43 @@ impl TitleScreen {
 
         Ok(())
     }
+
+    fn draw_git_info(stdout: &mut std::io::Stdout, git_info: Option<&GitRepositoryInfo>) -> Result<()> {
+        if let Some(info) = git_info {
+            let (terminal_width, terminal_height) = terminal::size()?;
+            let bottom_row = terminal_height - 1;
+            
+            // Build git info string
+            let mut parts = vec![
+                format!("📁 {}/{}", info.user_name, info.repository_name),
+            ];
+            
+            if let Some(ref branch) = info.branch {
+                parts.push(format!("🌿 {}", branch));
+            }
+            
+            if let Some(ref commit) = info.commit_hash {
+                parts.push(format!("📝 {}", &commit[..8]));
+            }
+            
+            let status_symbol = if info.is_dirty { "⚠️" } else { "✓" };
+            parts.push(status_symbol.to_string());
+            
+            let git_text = parts.join(" • ");
+            
+            // Calculate approximate display width considering emoji width
+            // Each emoji takes about 2 characters worth of width
+            let emoji_count = git_text.chars().filter(|c| *c as u32 > 127).count();
+            let approximate_width = git_text.chars().count() + emoji_count;
+            
+            // Center the text using approximate width
+            let git_col = terminal_width.saturating_sub(approximate_width as u16) / 2;
+            
+            execute!(stdout, MoveTo(git_col, bottom_row))?;
+            execute!(stdout, SetForegroundColor(Color::DarkGrey))?;
+            execute!(stdout, Print(&git_text))?;
+            execute!(stdout, ResetColor)?;
+        }
+        Ok(())
+    }
 }
diff --git a/src/game/stage_manager.rs b/src/game/stage_manager.rs
@@ -1,5 +1,6 @@
 use crate::Result;
 use crate::scoring::{TypingMetrics, ScoringEngine};
+use crate::extractor::GitRepositoryInfo;
 use crossterm::terminal;
 use std::sync::{Arc, Mutex};
 use once_cell::sync::Lazy;
@@ -22,6 +23,7 @@ pub struct StageManager {
     stage_engines: Vec<(String, ScoringEngine)>,
     current_game_mode: Option<GameMode>,
     session_tracker: SessionTracker,
+    git_info: Option<GitRepositoryInfo>,
 }
 
 impl StageManager {
@@ -33,8 +35,13 @@ impl StageManager {
             stage_engines: Vec::new(),
             current_game_mode: None,
             session_tracker: SessionTracker::new(),
+            git_info: None,
         }
     }
+    
+    pub fn set_git_info(&mut self, git_info: Option<GitRepositoryInfo>) {
+        self.git_info = git_info;
+    }
 
     pub fn run_session(&mut self) -> Result<()> {
         // Set global session tracker for Ctrl+C handler
@@ -57,7 +64,7 @@ impl StageManager {
             // Count challenges by difficulty level
             let challenge_counts = self.count_challenges_by_difficulty();
             
-            match TitleScreen::show_with_challenge_counts(&challenge_counts)? {
+            match TitleScreen::show_with_challenge_counts_and_git_info(&challenge_counts, self.git_info.as_ref())? {
                 TitleAction::Start(difficulty) => {
                     // Build stages based on selected difficulty using pre-generated challenges
                     let game_mode = GameMode::Custom {
diff --git a/src/main.rs b/src/main.rs
@@ -148,6 +148,7 @@ fn main() -> anyhow::Result<()> {
                 
                 // Create StageManager with pre-generated challenges
                 let mut stage_manager = StageManager::new(available_challenges);
+                stage_manager.set_git_info(loader.get_git_info().clone());
                 match stage_manager.run_session() {
                     Ok(_) => {
                         // println!("Thanks for playing GitType!");
