// Removed: use std::path::PathBuf;

// This file previously contained functionality for scanning for TODO/FIXME comments.
// The code has been commented out as it is currently unused and potentially deprecated.
// If this functionality is needed in the future, it can be retrieved from version control history.

/*
/// Represents the type of discovered item (TODO or FIXME).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TodoKind {
    Todo,
    Fixme,
}

impl std::fmt::Display for TodoKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TodoKind::Todo => write!(f, "TODO"),
            TodoKind::Fixme => write!(f, "FIXME"),
        }
    }
}

/// Represents a single TODO or FIXME item found in the source code.
#[derive(Debug, Clone)]
pub struct TodoItem {
    pub file_path: PathBuf,
    pub line_number: usize,
    pub kind: TodoKind,
    pub content: String, // The text after TODO: or FIXME:
}
*/

/*
#[tracing::instrument(skip(dir))]
pub fn scan_directory(dir: &Path) -> Result<Vec<TodoItem>, io::Error> {
    let mut items = Vec::new();

    let todo_regex = Regex::new(r"(?i)//\s*(TODO|FIXME):\s*(.*)").unwrap();

    for entry in WalkDir::new(dir)
        .into_iter()
        .filter_map(Result::ok) // Ignore errors during iteration for simplicity
        .filter(|e| !e.file_type().is_dir())
    // Skip directories
    {
        let path = entry.path();

        if path.extension().is_some_and(|ext| ext == "rs") {
            match fs::read_to_string(path) {
                Ok(content) => {
                    for (line_number, line) in content.lines().enumerate() {
                        if let Some(caps) = todo_regex.captures(line) {
                            let kind_str = caps.get(1).map_or("", |m| m.as_str());
                            let content_str = caps.get(2).map_or("", |m| m.as_str()).trim();

                            let kind = match kind_str.to_uppercase().as_str() {
                                "TODO" => TodoKind::Todo,
                                "FIXME" => TodoKind::Fixme,
                                _ => continue, // Should not happen with the regex
                            };

                            items.push(TodoItem {
                                file_path: path.to_path_buf(),
                                kind,
                                line_number: line_number + 1, // lines are 1-indexed
                                content: content_str.to_string(),
                            });
                        }
                    }
                }
                Err(e) => {
                    tracing::warn!("Failed to read file {}: {}", path.display(), e);
                }
            }
        }
    }

    tracing::debug!(
        count = items.len(),
        dir = dir.display().to_string(),
        "Scan complete"
    );
    Ok(items)
}
*/
