feat: Implement AST-based code extraction with gitignore support

- Implement CodeExtractor with tree-sitter parsing for Rust, TypeScript, Python
- Add gitignore-aware file traversal using ignore crate
- Implement ExtractionOptions for configurable file patterns and max lines
- Add AST-based indentation normalization and comment range tracking
- Extract functions, methods, classes, structs, and impls as CodeChunks
- Add ChallengeConverter for transforming chunks to game challenges
- Implement RepositoryLoader for loading challenges from repositories

Core features:
- Respects .gitignore, global gitignore, and .git/info/exclude
- Normalizes indentation based on AST node column position
- Tracks comment ranges through text transformations
- Supports filtering by max line count and file patterns

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/error.rs

@@ -25,6 +25,9 @@ pub enum GitTypeError {
 
     #[error("Terminal error: {0}")]
     TerminalError(String),
+
+    #[error("Walk directory error: {0}")]
+    WalkDirError(#[from] walkdir::Error),
 }
 
 pub type Result<T> = std::result::Result<T, GitTypeError>;

src/extractor/challenge_converter.rs

@@ -0,0 +1,59 @@
+use crate::game::Challenge;
+use super::{CodeChunk, ChunkType};
+use uuid::Uuid;
+
+pub struct ChallengeConverter;
+
+impl ChallengeConverter {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn convert_chunk_to_challenge(&self, chunk: CodeChunk) -> Challenge {
+        let id = Uuid::new_v4().to_string();
+        let language = self.language_to_string(&chunk.language);
+        let file_path = chunk.file_path.to_string_lossy().to_string();
+        
+        Challenge::new(id, chunk.content)
+            .with_source_info(file_path, chunk.start_line, chunk.end_line)
+            .with_language(language)
+            .with_comment_ranges(chunk.comment_ranges)
+    }
+
+    pub fn convert_chunks_to_challenges(&self, chunks: Vec<CodeChunk>) -> Vec<Challenge> {
+        chunks.into_iter()
+            .map(|chunk| self.convert_chunk_to_challenge(chunk))
+            .collect()
+    }
+
+    pub fn convert_with_filter<F>(&self, chunks: Vec<CodeChunk>, filter: F) -> Vec<Challenge>
+    where
+        F: Fn(&CodeChunk) -> bool,
+    {
+        chunks.into_iter()
+            .filter(filter)
+            .map(|chunk| self.convert_chunk_to_challenge(chunk))
+            .collect()
+    }
+
+    pub fn convert_functions_only(&self, chunks: Vec<CodeChunk>) -> Vec<Challenge> {
+        self.convert_with_filter(chunks, |chunk| {
+            matches!(chunk.chunk_type, ChunkType::Function | ChunkType::Method)
+        })
+    }
+
+    pub fn convert_classes_only(&self, chunks: Vec<CodeChunk>) -> Vec<Challenge> {
+        self.convert_with_filter(chunks, |chunk| {
+            matches!(chunk.chunk_type, ChunkType::Class | ChunkType::Struct)
+        })
+    }
+
+    fn language_to_string(&self, language: &super::Language) -> String {
+        match language {
+            super::Language::Rust => "rust".to_string(),
+            super::Language::TypeScript => "typescript".to_string(),
+            super::Language::Python => "python".to_string(),
+        }
+    }
+}
+

src/extractor/chunk.rs

@@ -18,4 +18,6 @@ pub struct CodeChunk {
     pub language: Language,
     pub chunk_type: ChunkType,
     pub name: String,
+    pub comment_ranges: Vec<(usize, usize)>, // Character-based ranges for comments relative to content
+    pub original_indentation: usize, // Column position of the first character in source
 }

src/extractor/mod.rs

@@ -1,7 +1,11 @@
 pub mod language;
 pub mod parser;
 pub mod chunk;
+pub mod challenge_converter;
+pub mod repository_loader;
 
 pub use language::Language;
 pub use chunk::{CodeChunk, ChunkType};
-pub use parser::CodeExtractor;
+pub use parser::{CodeExtractor, ExtractionOptions};
+pub use challenge_converter::ChallengeConverter;
+pub use repository_loader::RepositoryLoader;