patchloom 0.31.0

use super::*;

#[test]
fn test_init_creates_agents_md_in_empty_dir() {
    let dir = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(output.status.success());
    let agents = dir.path().join("AGENTS.md");
    assert!(agents.exists(), "AGENTS.md should be created");
    let content = fs::read_to_string(&agents).unwrap();
    assert!(content.contains("patchloom"));
    assert!(content.contains("# Patchloom"));
}

#[test]
fn test_init_appends_to_existing_agents_md() {
    let dir = TempDir::new().unwrap();
    fs::write(dir.path().join("AGENTS.md"), "# My Rules\n").unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(output.status.success());
    let content = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(
        content.starts_with("# My Rules\n"),
        "original content should be preserved"
    );
    assert!(
        content.contains("# Patchloom"),
        "patchloom rules should be appended"
    );
}

#[test]
fn test_init_appends_when_existing_agents_mentions_patchloom_without_generated_header() {
    let dir = TempDir::new().unwrap();
    fs::write(
        dir.path().join("AGENTS.md"),
        "# Rules\nUse patchloom for edits.\n",
    )
    .unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert!(output.status.success());
    let content = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(content.starts_with("# Rules\nUse patchloom for edits.\n"));
    assert!(content.contains("# Patchloom"));
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("appended patchloom rules"));
}

#[test]
fn test_init_skips_if_patchloom_already_present() {
    let dir = TempDir::new().unwrap();
    fs::write(
        dir.path().join("AGENTS.md"),
        "# Rules\n<!-- Generated by patchloom v0.1.0 -->\n",
    )
    .unwrap();
    let before = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(output.status.success());
    let after = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert_eq!(before, after, "file should not be modified");
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("already contains patchloom rules"));
}

#[test]
fn test_init_errors_on_non_utf8_existing_agents_md() {
    let dir = TempDir::new().unwrap();
    let agents = dir.path().join("AGENTS.md");
    fs::write(&agents, [0xff, 0xfe, 0x00]).unwrap();
    let before = fs::read(&agents).unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert!(!output.status.success());
    assert_eq!(
        fs::read(&agents).unwrap(),
        before,
        "file should not be modified"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("could not read")
            && (stderr.contains("binary") || stderr.contains("UTF-8")),
        "human init must name the read failure: {stderr}"
    );
}

#[test]
fn test_init_appends_to_existing_claude_md() {
    let dir = TempDir::new().unwrap();
    let claude = dir.path().join("Claude.md");
    fs::write(&claude, "# Claude Rules\n").unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert!(output.status.success());
    assert!(!dir.path().join("AGENTS.md").exists());
    let content = fs::read_to_string(&claude).unwrap();
    assert!(content.starts_with("# Claude Rules\n"));
    assert!(content.contains("# Patchloom"));
}

#[test]
fn test_init_quiet_suppresses_output() {
    let dir = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--quiet", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(output.status.success());
    // File should still be created
    assert!(dir.path().join("AGENTS.md").exists());
    // But stderr should be empty
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.is_empty(), "stderr should be empty with --quiet");
}

/// Global --json must not leave agents with human text on stdout.
#[test]
fn test_init_json_emits_structured_report() {
    let dir = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "init", "--yes", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "stderr={}",
        String::from_utf8_lossy(&output.stderr)
    );
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {
        panic!(
            "init --json must be JSON ({e}): {}",
            String::from_utf8_lossy(&output.stdout)
        )
    });
    assert_eq!(json["ok"], true, "{json}");
    assert_eq!(json["agent_rules"], "created", "{json}");
    assert_eq!(json["agent_rules_path"], "AGENTS.md", "{json}");
    assert!(
        json["gitignore"].as_str().is_some_and(|s| !s.is_empty()),
        "gitignore field required: {json}"
    );
    assert!(dir.path().join("AGENTS.md").exists());
    assert!(
        json.get("error_kind").is_none() || json["error_kind"].is_null(),
        "success report must not set error_kind: {json}"
    );
}

/// Hard-fail init --json must set error_kind so agents can branch.
#[test]
fn test_init_json_hard_fail_sets_error_kind() {
    let dir = TempDir::new().unwrap();
    fs::write(dir.path().join("AGENTS.md"), b"hello \xff world").unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert_eq!(
        output.status.code(),
        Some(1),
        "stderr={}",
        String::from_utf8_lossy(&output.stderr)
    );
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {
        panic!(
            "init --json must be JSON ({e}): {}",
            String::from_utf8_lossy(&output.stdout)
        )
    });
    assert_eq!(json["ok"], false, "{json}");
    assert_eq!(json["error_kind"], "invalid_encoding", "{json}");
    assert!(
        json["error"]
            .as_str()
            .is_some_and(|s| s.contains("UTF-8") || s.contains("encoding")),
        "error must name encoding: {json}"
    );
    assert!(
        json["agent_rules"]
            .as_str()
            .is_some_and(|s| s.starts_with("error:")),
        "agent_rules still reports error: {json}"
    );
}

#[test]
fn test_init_json_agents_md_directory_sets_error_kind() {
    let dir = TempDir::new().unwrap();
    fs::create_dir(dir.path().join("AGENTS.md")).unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert_eq!(
        output.status.code(),
        Some(1),
        "stderr={}",
        String::from_utf8_lossy(&output.stderr)
    );
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(json["ok"], false, "{json}");
    assert_eq!(json["error_kind"], "invalid_input", "{json}");
    assert!(
        json["error"]
            .as_str()
            .is_some_and(|s| s.contains("not a file")),
        "error must name dest kind: {json}"
    );
}

/// #1833: `init --json` without `--yes` must still create AGENTS.md (agent bootstrap).
#[test]
fn test_init_json_without_yes_creates_agents_md() {
    let dir = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "init", "--cwd"])
        .arg(dir.path())
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "stderr={}",
        String::from_utf8_lossy(&output.stderr)
    );
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {
        panic!(
            "init --json must be JSON ({e}): {}",
            String::from_utf8_lossy(&output.stdout)
        )
    });
    assert_eq!(json["ok"], true, "{json}");
    assert_eq!(
        json["agent_rules"], "created",
        "structured init must not skip AGENTS.md without --yes (#1833): {json}"
    );
    assert!(
        dir.path().join("AGENTS.md").exists(),
        "AGENTS.md must exist after init --json without --yes"
    );
    assert!(
        dir.path().join(".gitignore").exists(),
        "structured init must still write .gitignore (auto-accept)"
    );
    let content = fs::read_to_string(dir.path().join("AGENTS.md")).unwrap();
    assert!(
        content.contains("patchloom") || content.len() > 100,
        "AGENTS.md should contain generated rules"
    );
}

#[test]
fn test_init_falls_back_to_completion_command_when_completion_dir_creation_fails() {
    let dir = TempDir::new().unwrap();
    let fake_home = dir.path().join("fake-home");
    let blocking_file = fake_home.join(".config");
    fs::create_dir_all(&fake_home).unwrap();
    fs::write(&blocking_file, "not a directory\n").unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("HOME", &fake_home)
        .env("SHELL", "fish")
        .output()
        .unwrap();
    assert!(output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("failed to prepare completion directory:"));
    assert!(
        stderr.contains("patchloom completions fish > ~/.config/fish/completions/patchloom.fish")
    );
}

#[cfg(unix)]
#[test]
fn test_init_confirm_eof_skips_agents_creation() {
    let dir = TempDir::new().unwrap();
    // Two prompts now: AGENTS.md and .gitignore. EOF on each declines both.
    let output = run_patchloom_confirm_in_pty_with_env(
        &["init", "--cwd", dir.path().to_str().unwrap()],
        "\u{4}\u{4}",
        &[("SHELL", "unknown")],
    );

    assert!(output.status.success());
    assert!(!dir.path().join("AGENTS.md").exists());
    assert!(
        !dir.path().join(".gitignore").exists(),
        "declined gitignore must not create .gitignore"
    );

    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("Create AGENTS.md? [Y/n]"));
    assert!(
        stdout.contains("skipped AGENTS.md")
            && stdout.contains("--yes")
            && stdout.contains("--json"),
        "decline must name remediation flags: {stdout}"
    );
}

/// Non-TTY plain `init` (no --yes) declines confirm and must not look like a silent no-op (#1922 / fixrealloop).
#[test]
fn test_init_noninteractive_without_yes_hints_use_yes() {
    let dir = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--cwd"])
        .arg(dir.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();
    assert!(output.status.success());
    assert!(
        !dir.path().join("AGENTS.md").exists(),
        "non-interactive init without --yes must not create AGENTS.md"
    );
    assert!(
        !dir.path().join(".gitignore").exists(),
        "non-interactive init without --yes must not silently create .gitignore"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("skipped AGENTS.md")
            && stderr.contains("--yes")
            && stderr.contains("--json"),
        "stderr must explain how to create rules: {stderr}"
    );
    assert!(
        stderr.contains("skipped .gitignore") || stderr.contains(".gitignore"),
        "stderr must mention gitignore skip: {stderr}"
    );
}

#[cfg(feature = "mcp")]
#[test]
fn test_init_shows_vscode_mcp_json_hint() {
    if !has_mcp_support() {
        return;
    }

    let dir = TempDir::new().unwrap();
    fs::create_dir(dir.path().join(".vscode")).unwrap();
    let home = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("HOME", home.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();

    assert!(output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("VS Code: create .vscode/mcp.json:"));
    assert!(stderr.contains(
        "\"servers\": { \"patchloom\": { \"command\": \"patchloom\", \"args\": [\"mcp-server\"] } }"
    ));
    assert!(!stderr.contains(".vscode/settings.json"));
}

#[cfg(feature = "mcp")]
#[test]
fn test_init_shows_cursor_mcp_json_hint() {
    if !has_mcp_support() {
        return;
    }

    let dir = TempDir::new().unwrap();
    fs::create_dir(dir.path().join(".cursor")).unwrap();
    let home = TempDir::new().unwrap();
    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["init", "--yes", "--cwd"])
        .arg(dir.path())
        .env("HOME", home.path())
        .env("SHELL", "unknown")
        .output()
        .unwrap();

    assert!(output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("Cursor: create .cursor/mcp.json:"));
    assert!(stderr.contains(
        "\"servers\": { \"patchloom\": { \"command\": \"patchloom\", \"args\": [\"mcp-server\"] } }"
    ));
}

// ---------------------------------------------------------------------------
// --glob flag
// ---------------------------------------------------------------------------