@nozich/git-mood 0.1.2

package/README.md

@@ -0,0 +1,88 @@
+# 🎨 git-mood
+
+> Color your GitHub contribution graph with the mood of your git commits.
+
+`git-mood` is a blazingly fast, zero-dependency local CLI tool written in Rust. It hooks into your git workflow, analyzes the sentiment of your commit messages and diff stats in real time, and logs your daily coding "mood". 
+
+Using a local database, it generates a beautiful, custom-colored contribution graph SVG (shining with **Turquoise**, **Red**, **Yellow**, **Purple**, and **Green**) that you can embed directly in your GitHub Profile README.
+
+---
+
+## 🎭 The Mood Map
+
+| Color | Mood | Trigger Rule |
+| :--- | :--- | :--- |
+| **🔵 Turquoise** | **Productive & Happy** | Commits with positive keywords (`feat`, `add`, `awesome`, `super`, `love`, `success`) |
+| **🔴 Red** | **Bug-Fixing / Stressed** | Commits containing bugs, fails, crashes, errors, or swear words |
+| **🟡 Yellow** | **Cleanups & Refactoring** | Commits with refactor keywords OR where deletions represent $\ge 70\%$ of the total diff |
+| **🟣 Purple** | **Weekend Warrior** | Commits made on Saturday or Sunday |
+| **🟢 Green** | **Steady Progress** | Default / Neutral commits (chores, fixes, docs) |
+
+---
+
+## 🚀 Key Features
+
+- **Blazingly Fast**: Compiled binary in Rust. Starts and finishes in less than 2 milliseconds.
+- **Privacy First**: Fully local. No external AI APIs, no trackers, no network requests during commit.
+- **Smart Diff Parsing**: Dynamically calculates refactoring mood when you delete more code than you write.
+- **Sleek Dark Mode SVG**: Generates a premium, responsive widget that matches GitHub's dark theme perfectly.
+
+---
+
+## 📦 Installation
+
+Download the precompiled binary for your system from the [Latest Releases](https://github.com/anilcan-kara/git-mood/releases):
+
+- **macOS (Apple Silicon)**: [git-mood-darwin-arm64](https://github.com/anilcan-kara/git-mood/releases/latest/download/git-mood-darwin-arm64)
+- **macOS (Intel)**: [git-mood-darwin-x64](https://github.com/anilcan-kara/git-mood/releases/latest/download/git-mood-darwin-x64)
+- **Linux (x64)**: [git-mood-linux-x64](https://github.com/anilcan-kara/git-mood/releases/latest/download/git-mood-linux-x64)
+- **Linux (ARM64)**: [git-mood-linux-arm64](https://github.com/anilcan-kara/git-mood/releases/latest/download/git-mood-linux-arm64)
+- **Windows (x64)**: [git-mood-win32-x64.exe](https://github.com/anilcan-kara/git-mood/releases/latest/download/git-mood-win32-x64.exe)
+
+Move the downloaded binary to a folder in your system `$PATH` (e.g. `/usr/local/bin` or `%USERPROFILE%\AppData\Local\Microsoft\WindowsApps`) and rename it to `git-mood`.
+
+---
+
+## 🛠️ Usage
+
+### 1. Initialize hook in your project
+Navigate to any git repository and initialize the commit-msg hook:
+```bash
+git-mood init
+```
+
+### 2. Write code & commit
+Work on your code as usual. When you commit, `git-mood` automatically analyzes the message and prints live feedback:
+```bash
+git commit -m "feat: add beautiful dashboard ui"
+
+# Output:
+# [git-mood] Sentiment Analyzed: Positive (Turquoise) 🚀
+#            Diff: +142 / -12 lines
+```
+
+### 3. Check your mood dashboard
+See a weekly breakdown and stats directly in your terminal:
+```bash
+git-mood status
+```
+
+### 4. Sync to your GitHub Profile
+To show your custom mood contribution graph on your GitHub Profile:
+
+1. Clone your special **GitHub Profile Repository** (the repo with the same name as your username, e.g., `github.com/username/username`).
+2. Run `git-mood sync` inside that repository:
+   ```bash
+   git-mood sync
+   ```
+   This will generate a `git-mood.svg` file, automatically commit it, and push it to your remote repo!
+3. Add the following line to your Profile `README.md`:
+   ```markdown
+   ![git-mood](https://raw.githubusercontent.com/<your-username>/<your-username>/main/git-mood.svg)
+   ```
+
+---
+
+## 🛡️ License
+
+MIT License. See [LICENSE](LICENSE) for details.

package/bin/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { spawn } = require('child_process');
+
+const VERSION = '0.1.2';
+const REPO = 'anilcan-kara/git-mood';
+
+const platform = process.platform;
+const arch = process.arch;
+
+let osKey = '';
+let ext = '';
+
+if (platform === 'win32') {
+  osKey = 'win32';
+  ext = '.exe';
+} else if (platform === 'darwin') {
+  osKey = 'darwin';
+} else if (platform === 'linux') {
+  osKey = 'linux';
+} else {
+  console.error(`[git-mood] Unsupported platform: ${platform}`);
+  process.exit(1);
+}
+
+let archKey = '';
+if (arch === 'x64') {
+  archKey = 'x64';
+} else if (arch === 'arm64') {
+  archKey = 'arm64';
+} else {
+  console.error(`[git-mood] Unsupported architecture: ${arch}`);
+  process.exit(1);
+}
+
+const binaryName = `git-mood-${osKey}-${archKey}${ext}`;
+const targetDir = path.join(__dirname, '..', 'dist');
+const binaryPath = path.join(targetDir, `git-mood${ext}`);
+const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${binaryName}`;
+
+function downloadFile(url, dest, callback) {
+  https.get(url, (res) => {
+    if (res.statusCode === 302 || res.statusCode === 301) {
+      downloadFile(res.headers.location, dest, callback);
+      return;
+    }
+    if (res.statusCode !== 200) {
+      callback(new Error(`Failed to download binary: HTTP ${res.statusCode}`));
+      return;
+    }
+    const file = fs.createWriteStream(dest);
+    res.pipe(file);
+    file.on('finish', () => {
+      file.close(callback);
+    });
+  }).on('error', (err) => {
+    fs.unlink(dest, () => {});
+    callback(err);
+  });
+}
+
+fnRunBinary = () => {
+  const args = process.argv.slice(2);
+  const child = spawn(binaryPath, args, { stdio: 'inherit' });
+
+  child.on('close', (code) => {
+    process.exit(code === null ? 1 : code);
+  });
+
+  child.on('error', (err) => {
+    console.error(`[git-mood] Failed to start binary:`, err);
+    process.exit(1);
+  });
+};
+
+if (fs.existsSync(binaryPath)) {
+  fnRunBinary();
+} else {
+  console.log(`\x1b[36m[git-mood]\x1b[0m Downloading platform binary v${VERSION} (${osKey}-${archKey})...`);
+  
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  downloadFile(downloadUrl, binaryPath, (err) => {
+    if (err) {
+      console.error(`\x1b[31m[git-mood] Download failed:\x1b[0m`, err.message);
+      console.error(`Please download git-mood manually from https://github.com/${REPO}/releases`);
+      process.exit(1);
+    }
+
+    if (platform !== 'win32') {
+      try {
+        fs.chmodSync(binaryPath, 0755);
+      } catch (chmodErr) {
+        console.warn(`[git-mood] Failed to set permissions:`, chmodErr);
+      }
+    }
+
+    console.log(`\x1b[32m[git-mood] Binary downloaded successfully!\x1b[0m\n`);
+    fnRunBinary();
+  });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@nozich/git-mood",
+  "version": "0.1.2",
+  "description": "Color your GitHub contribution graph with the mood of your git commits",
+  "main": "bin/cli.js",
+  "bin": {
+    "git-mood": "./bin/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anilcan-kara/git-mood.git"
+  },
+  "keywords": [
+    "git",
+    "mood",
+    "contribution",
+    "github",
+    "profile",
+    "visualization",
+    "sentiment",
+    "rust"
+  ],
+  "author": "Anilcan Kara",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/anilcan-kara/git-mood/issues"
+  },
+  "homepage": "https://github.com/anilcan-kara/git-mood#readme",
+  "engines": {
+    "node": ">=14"
+  }
+}

package/src/hook.rs

@@ -0,0 +1,70 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+
+pub fn install_hook() -> Result<(), String> {
+    // Find git repo root using git rev-parse
+    let output = Command::new("git")
+        .args(["rev-parse", "--show-toplevel"])
+        .output()
+        .map_err(|e| format!("Failed to run git: {}", e))?;
+
+    if !output.status.success() {
+        return Err("Not inside a git repository".to_string());
+    }
+
+    let repo_root_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    let repo_root = Path::new(&repo_root_str);
+    let hook_dir = repo_root.join(".git").join("hooks");
+
+    if !hook_dir.exists() {
+        fs::create_dir_all(&hook_dir)
+            .map_err(|e| format!("Failed to create hooks directory: {}", e))?;
+    }
+
+    let hook_path = hook_dir.join("commit-msg");
+
+    // Get current executable path
+    let current_exe = std::env::current_exe()
+        .map_err(|e| format!("Failed to get current executable path: {}", e))?;
+    let exe_path_str = current_exe.to_string_lossy().replace('\\', "/");
+
+    // Check if there is already a hook and back it up
+    if hook_path.exists() {
+        let existing_content = fs::read_to_string(&hook_path).unwrap_or_default();
+        if existing_content.contains("git-mood") {
+            println!("git-mood hook already installed in this repository.");
+            return Ok(());
+        }
+        let backup_path = hook_path.with_extension("backup");
+        fs::copy(&hook_path, &backup_path)
+            .map_err(|e| format!("Failed to back up existing hook: {}", e))?;
+        println!("Existing commit-msg hook backed up to {:?}", backup_path);
+    }
+
+    // Shell script template (works on Windows via Git Bash and Unix natively)
+    let hook_content = format!(
+        "#!/bin/sh\n\n# git-mood commit-msg hook\n\"{}\" commit-hook \"$1\"\n",
+        exe_path_str
+    );
+
+    fs::write(&hook_path, hook_content)
+        .map_err(|e| format!("Failed to write hook file: {}", e))?;
+
+    // Make the hook executable on Unix
+    #[cfg(unix)]
+    {
+        let mut perms = fs::metadata(&hook_path)
+            .map_err(|e| format!("Failed to get hook metadata: {}", e))?
+            .permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&hook_path, perms)
+            .map_err(|e| format!("Failed to set hook permissions: {}", e))?;
+    }
+
+    println!("git-mood hook successfully installed at {:?}", hook_path);
+    Ok(())
+}

package/src/main.rs

@@ -0,0 +1,264 @@
+mod sentiment;
+mod hook;
+mod svg;
+
+use std::collections::HashMap;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use chrono::{Local, Datelike};
+use colored::Colorize;
+use sentiment::Mood;
+use svg::DayStats;
+
+fn get_log_path() -> PathBuf {
+    let home = env::var("USERPROFILE")
+        .or_else(|_| env::var("HOME"))
+        .unwrap_or_else(|_| ".".to_string());
+    Path::new(&home).join(".git-mood.json")
+}
+
+fn load_db(path: &Path) -> HashMap<String, DayStats> {
+    if !path.exists() {
+        return HashMap::new();
+    }
+    let content = fs::read_to_string(path).unwrap_or_default();
+    serde_json::from_str(&content).unwrap_or_default()
+}
+
+fn save_db(path: &Path, db: &HashMap<String, DayStats>) -> Result<(), String> {
+    let content = serde_json::to_string_pretty(db).map_err(|e| e.to_string())?;
+    fs::write(path, content).map_err(|e| e.to_string())
+}
+
+fn get_diff_stats() -> (usize, usize) {
+    let output = Command::new("git")
+        .args(["diff", "--cached", "--numstat"])
+        .output();
+
+    let mut insertions = 0;
+    let mut deletions = 0;
+
+    if let Ok(out) = output {
+        if out.status.success() {
+            let stdout_str = String::from_utf8_lossy(&out.stdout);
+            for line in stdout_str.lines() {
+                let parts: Vec<&str> = line.split_whitespace().collect();
+                if parts.len() >= 2 {
+                    let ins: usize = parts[0].parse().unwrap_or(0);
+                    let del: usize = parts[1].parse().unwrap_or(0);
+                    insertions += ins;
+                    deletions += del;
+                }
+            }
+        }
+    }
+
+    (insertions, deletions)
+}
+
+fn print_help() {
+    println!("{}", "==============================================".cyan());
+    println!("        {} - GitHub Graph Colorizer", "git-mood".green().bold());
+    println!("{}", "==============================================".cyan());
+    println!("Usage:");
+    println!("  git-mood init           Install git hook in the current repository");
+    println!("  git-mood status         Display terminal dashboard of your moods");
+    println!("  git-mood sync           Generate git-mood.svg and push it to profile");
+    println!();
+    println!("Hook Command (Internal):");
+    println!("  git-mood commit-hook <file>  Analyze commit message file");
+    println!("{}", "==============================================".cyan());
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        print_help();
+        return;
+    }
+
+    match args[1].as_str() {
+        "init" => {
+            println!("Initializing git-mood hook...");
+            if let Err(e) = hook::install_hook() {
+                eprintln!("{}: {}", "Error".red().bold(), e);
+            }
+        }
+        "commit-hook" => {
+            if args.len() < 3 {
+                eprintln!("{}: Missing commit message file path", "Error".red().bold());
+                return;
+            }
+            let msg_file = &args[2];
+            let commit_msg = match fs::read_to_string(msg_file) {
+                Ok(content) => content,
+                Err(e) => {
+                    eprintln!("{}: Failed to read commit msg: {}", "Error".red().bold(), e);
+                    return;
+                }
+            };
+
+            // Analyze
+            let (insertions, deletions) = get_diff_stats();
+            let today = Local::now().date_naive();
+            let weekday = today.weekday();
+            let is_weekend = weekday == chrono::Weekday::Sat || weekday == chrono::Weekday::Sun;
+
+            let mood = sentiment::analyze_commit(&commit_msg, insertions, deletions, is_weekend);
+
+            // Update database
+            let db_path = get_log_path();
+            let mut db = load_db(&db_path);
+            let date_key = today.format("%Y-%m-%d").to_string();
+
+            let mut stats = db.entry(date_key).or_insert_with(DayStats::default);
+            stats.commits_count += 1;
+            match mood {
+                Mood::Positive => stats.positive += 1,
+                Mood::Negative => stats.negative += 1,
+                Mood::Neutral => stats.neutral += 1,
+                Mood::Refactor => stats.refactor += 1,
+                Mood::Weekend => stats.weekend += 1,
+            }
+
+            if let Err(e) = save_db(&db_path, &db) {
+                eprintln!("{}: Failed to save mood: {}", "Error".red().bold(), e);
+                return;
+            }
+
+            // Print feedback to the developer during their git workflow!
+            let colored_mood = match mood {
+                Mood::Positive => "Positive (Turquoise) 🚀".cyan().bold(),
+                Mood::Negative => "Stressed / Negative (Red) ⚠️".red().bold(),
+                Mood::Neutral => "Steady / Neutral (Green) 🟩".green().bold(),
+                Mood::Refactor => "Refactor / Cleanup (Yellow) 🟨".yellow().bold(),
+                Mood::Weekend => "Weekend Coding (Purple) 🟪".magenta().bold(),
+            };
+
+            println!();
+            println!(" [git-mood] Sentiment Analyzed: {}", colored_mood);
+            println!("            Diff: +{} / -{} lines", insertions, deletions);
+            println!();
+        }
+        "status" => {
+            let db_path = get_log_path();
+            let db = load_db(&db_path);
+
+            println!("{}", "\n--- Your git-mood Dashboard ---".cyan().bold());
+            if db.is_empty() {
+                println!("No commits tracked yet. Run `git-mood init` in a repo to start logging!");
+                return;
+            }
+
+            // Print summary of last 7 days
+            let today = Local::now().date_naive();
+            println!("\nRecent Days:");
+            for i in (0..7).rev() {
+                let day = today - chrono::Duration::days(i);
+                let date_str = day.format("%Y-%m-%d").to_string();
+                let day_name = day.format("%A").to_string();
+
+                if let Some(stats) = db.get(&date_str) {
+                    if let Some(m) = stats.determine_mood() {
+                        let block = match m {
+                            Mood::Positive => "■".cyan(),
+                            Mood::Negative => "■".red(),
+                            Mood::Neutral => "■".green(),
+                            Mood::Refactor => "■".yellow(),
+                            Mood::Weekend => "■".magenta(),
+                        };
+                        println!("  {} ({}): {} [{} commits]", day_name, date_str, block, stats.commits_count);
+                        continue;
+                    }
+                }
+                // If no commits
+                println!("  {} ({}): {} [0 commits]", day_name, date_str, "■".truecolor(80, 80, 80));
+            }
+
+            // Dominant overall mood breakdown
+            let mut mood_counts = HashMap::new();
+            let mut total_commits = 0;
+            for stats in db.values() {
+                total_commits += stats.commits_count;
+                if let Some(m) = stats.determine_mood() {
+                    *mood_counts.entry(m).or_insert(0) += 1;
+                }
+            }
+
+            println!("\nOverall Stats:");
+            println!("  Total Commits: {}", total_commits);
+            for (m, count) in &mood_counts {
+                let name = match m {
+                    Mood::Positive => "Turquoise (Positive)".cyan(),
+                    Mood::Negative => "Red (Negative)".red(),
+                    Mood::Neutral => "Green (Neutral)".green(),
+                    Mood::Refactor => "Yellow (Refactoring)".yellow(),
+                    Mood::Weekend => "Purple (Weekend)".magenta(),
+                };
+                println!("  {}: {} days", name, count);
+            }
+            println!();
+        }
+        "sync" => {
+            println!("{} Generating git-mood.svg...", "[git-mood]".green());
+            let db_path = get_log_path();
+            let db = load_db(&db_path);
+
+            let svg_content = svg::generate_svg(&db);
+            let svg_path = Path::new("git-mood.svg");
+
+            if let Err(e) = fs::write(svg_path, svg_content) {
+                eprintln!("{}: Failed to write SVG file: {}", "Error".red().bold(), e);
+                return;
+            }
+            println!("{} Saved SVG to {:?}", "[git-mood]".green(), svg_path);
+
+            // Check if git repository to perform auto-commit/push
+            if Path::new(".git").exists() {
+                println!("{} Detected local git repository. Committing and pushing SVG...", "[git-mood]".green());
+                
+                // git add
+                let add_status = Command::new("git")
+                    .args(["add", "git-mood.svg"])
+                    .status();
+
+                if let Ok(status) = add_status {
+                    if status.success() {
+                        // git commit
+                        let commit_status = Command::new("git")
+                            .args(["commit", "-m", "docs: update git-mood contribution graph [skip ci]", "--no-verify"])
+                            .status();
+
+                        if let Ok(c_status) = commit_status {
+                            if c_status.success() {
+                                println!("{} Committed changes.", "[git-mood]".green());
+                                
+                                // git push
+                                let push_status = Command::new("git")
+                                    .args(["push"])
+                                    .status();
+
+                                if let Ok(p_status) = push_status {
+                                    if p_status.success() {
+                                        println!("{} Successfully pushed to remote!", "[git-mood]".green());
+                                    } else {
+                                        println!("{} Push failed. You may need to run 'git push' manually.", "[git-mood]".yellow());
+                                    }
+                                }
+                            } else {
+                                println!("{} No new changes to commit or commit failed.", "[git-mood]".yellow());
+                            }
+                        }
+                    }
+                }
+            } else {
+                println!("{} Not a git repository or no .git folder found locally. Skipping git push.", "[git-mood]".yellow());
+            }
+        }
+        _ => {
+            print_help();
+        }
+    }
+}

package/src/sentiment.rs

@@ -0,0 +1,120 @@
+use std::fmt;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Mood {
+    Positive, // Turquoise
+    Negative, // Red
+    Neutral,  // Green
+    Refactor, // Yellow
+    Weekend,  // Purple
+}
+
+impl Mood {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Mood::Positive => "positive",
+            Mood::Negative => "negative",
+            Mood::Neutral => "neutral",
+            Mood::Refactor => "refactor",
+            Mood::Weekend => "weekend",
+        }
+    }
+
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "positive" => Some(Mood::Positive),
+            "negative" => Some(Mood::Negative),
+            "neutral" => Some(Mood::Neutral),
+            "refactor" => Some(Mood::Refactor),
+            "weekend" => Some(Mood::Weekend),
+            _ => None,
+        }
+    }
+
+    pub fn to_color_code(&self) -> &'static str {
+        match self {
+            Mood::Positive => "#00f2fe", // Turquoise
+            Mood::Negative => "#ff0844", // Red
+            Mood::Refactor => "#f6d365", // Yellow
+            Mood::Weekend => "#7f00ff",  // Purple
+            Mood::Neutral => "#00cdac",  // Green
+        }
+    }
+}
+
+impl fmt::Display for Mood {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+pub fn analyze_commit(
+    message: &str,
+    insertions: usize,
+    deletions: usize,
+    is_weekend: bool,
+) -> Mood {
+    let lower_msg = message.to_lowercase();
+
+    // 1. Check for Negative / Stress Keywords (High Priority)
+    let negative_keywords = [
+        "fuck", "shit", "damn", "hate", "hell", "stuck", "broken", "fail", "error",
+        "wrong", "panic", "crash", "issue", "ugly", "mess", "bug", "wtf", "stupid",
+        "annoying", "rage", "die", "nonsense", "garbage", "trash", "crap",
+    ];
+    for kw in &negative_keywords {
+        if lower_msg.contains(kw) {
+            return Mood::Negative;
+        }
+    }
+
+    // 2. Check for Refactor / Cleanup (Yellow)
+    let total_changes = insertions + deletions;
+    let is_refactor_keyword = lower_msg.contains("refactor")
+        || lower_msg.contains("cleanup")
+        || lower_msg.contains("simplify")
+        || lower_msg.contains("remove")
+        || lower_msg.contains("delete");
+
+    let is_heavy_deletions = total_changes > 10 && (deletions as f64 / total_changes as f64) >= 0.70;
+
+    if is_refactor_keyword || is_heavy_deletions {
+        return Mood::Refactor;
+    }
+
+    // 3. Check for Weekend Warrior (Purple)
+    if is_weekend && total_changes > 0 {
+        return Mood::Weekend;
+    }
+
+    // 4. Check for Positive (Turquoise)
+    let positive_keywords = [
+        "feat", "add", "improve", "perf", "docs", "love", "great", "awesome",
+        "easy", "solved", "fixed", "clean", "nice", "super", "happy", "resolve",
+        "success", "optimize", "cool", "proud", "perfect", "magic", "beautiful",
+    ];
+    for kw in &positive_keywords {
+        if lower_msg.contains(kw) {
+            return Mood::Positive;
+        }
+    }
+
+    // 5. Default/Neutral (Green)
+    Mood::Neutral
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sentiment_analysis() {
+        assert_eq!(analyze_commit("feat: add login page", 100, 0, false), Mood::Positive);
+        assert_eq!(analyze_commit("fix: stupid crash on login", 2, 2, false), Mood::Negative);
+        assert_eq!(analyze_commit("refactor auth flows", 10, 50, false), Mood::Refactor);
+        assert_eq!(analyze_commit("clean up helper functions", 5, 20, false), Mood::Refactor);
+        assert_eq!(analyze_commit("change some config", 5, 0, true), Mood::Weekend);
+        assert_eq!(analyze_commit("chore: update readme", 1, 1, false), Mood::Neutral);
+    }
+}