Change default root directory to use .demon subdirectory

- Modified find_git_root() to create and return <git_root>/.demon instead of <git_root>
- Auto-creates .demon directory if it doesn't exist
- Added proper error handling for edge cases (file vs directory conflicts, permissions)
- Maintains backward compatibility with explicit --root-dir flag
- Added comprehensive test to verify new default behavior
- Fixed test argument ordering for test_list_empty

Files are now organized as:
- Before: /project/daemon.pid, /project/daemon.stdout, /project/daemon.stderr
- After: /project/.demon/daemon.pid, /project/.demon/daemon.stdout, /project/.demon/daemon.stderr

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

Co-Authored-By: Claude <[email protected]>

2 files changed, 74 insertions, 4 deletions

diff --git a/src/main.rs b/src/main.rs
index 6fbab07..dd7793f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -327,10 +327,11 @@ fn run_command(command: Commands) -> Result<()> {
 fn find_git_root() -> Result<PathBuf> {
     let mut current = std::env::current_dir()?;
     
-    loop {
+    // Find the git root directory
+    let git_root = loop {
         let git_path = current.join(".git");
         if git_path.exists() {
-            return Ok(current);
+            break current;
         }
         
         match current.parent() {
@@ -339,7 +340,30 @@ fn find_git_root() -> Result<PathBuf> {
                 "No git repository found. Please specify --root-dir or run from within a git repository"
             )),
         }
+    };
+    
+    // Create .demon subdirectory within git root
+    let demon_dir = git_root.join(".demon");
+    
+    // Handle the case where .demon already exists
+    if demon_dir.exists() {
+        if !demon_dir.is_dir() {
+            return Err(anyhow::anyhow!(
+                "Path {} exists but is not a directory. Please remove it or specify --root-dir",
+                demon_dir.display()
+            ));
+        }
+        // .demon exists and is a directory, we can use it
+        return Ok(demon_dir);
     }
+    
+    // Create .demon directory
+    std::fs::create_dir(&demon_dir)
+        .with_context(|| format!("Failed to create daemon directory {}", demon_dir.display()))?;
+    
+    tracing::info!("Created daemon directory: {}", demon_dir.display());
+    
+    Ok(demon_dir)
 }
 
 fn resolve_root_dir(global: &Global) -> Result<PathBuf> {
diff --git a/tests/cli.rs b/tests/cli.rs
index 005468c..b97d331 100644
--- a/tests/cli.rs
+++ b/tests/cli.rs
@@ -1,6 +1,7 @@
 use assert_cmd::Command;
 use predicates::prelude::*;
 use std::fs;
+use std::path::PathBuf;
 use std::time::Duration;
 use tempfile::TempDir;
 
@@ -95,8 +96,7 @@ fn test_list_empty() {
     let temp_dir = TempDir::new().unwrap();
 
     let mut cmd = Command::cargo_bin("demon").unwrap();
-    cmd.args(["--root-dir", temp_dir.path().to_str().unwrap()])
-        .args(&["list"])
+    cmd.args(&["list", "--root-dir", temp_dir.path().to_str().unwrap()])
         .assert()
         .success()
         .stdout(predicate::str::contains("ID"))
@@ -340,6 +340,52 @@ fn test_clean_removes_stdout_stderr_files() {
 }
 
 #[test]
+fn test_default_demon_directory_creation() {
+    // This test verifies that when no --root-dir is specified,
+    // the system creates and uses a .demon subdirectory in the git root
+    
+    // Create a temporary git repo
+    let temp_dir = TempDir::new().unwrap();
+    let git_dir = temp_dir.path().join(".git");
+    std::fs::create_dir(&git_dir).unwrap();
+    
+    // Change to the temp directory
+    let original_dir = std::env::current_dir().unwrap();
+    std::env::set_current_dir(temp_dir.path()).unwrap();
+    
+    // Restore directory when done
+    struct DirGuard(PathBuf);
+    impl Drop for DirGuard {
+        fn drop(&mut self) {
+            let _ = std::env::set_current_dir(&self.0);
+        }
+    }
+    let _guard = DirGuard(original_dir);
+    
+    // Run a command without --root-dir to test default behavior
+    let mut cmd = Command::cargo_bin("demon").unwrap();
+    cmd.args(&["run", "default_test", "echo", "hello"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Started daemon 'default_test'"));
+    
+    // Wait for process to complete
+    std::thread::sleep(Duration::from_millis(100));
+    
+    // Verify that .demon directory was created and files are in it
+    let demon_dir = temp_dir.path().join(".demon");
+    assert!(demon_dir.exists());
+    assert!(demon_dir.is_dir());
+    assert!(demon_dir.join("default_test.pid").exists());
+    assert!(demon_dir.join("default_test.stdout").exists());
+    assert!(demon_dir.join("default_test.stderr").exists());
+    
+    // Verify the stdout content
+    let stdout_content = fs::read_to_string(demon_dir.join("default_test.stdout")).unwrap();
+    assert_eq!(stdout_content.trim(), "hello");
+}
+
+#[test]
 fn test_run_with_complex_command() {
     let temp_dir = TempDir::new().unwrap();