huskies/server/src/chat/transport/matrix/new_project.rs

//! `new project <name>` chat command — Phase 2a stack-overlay framework.
//!
//! Provisions a project container and registers it with the gateway.
//! The command is gateway-only: `new project <name> [--stack <stack>]`.
//!
//! Without `--stack`, the orchestrator inspects the (just-cloned or
//! just-init'd) source tree for stack markers found in
//! `docker/stacks/<name>/markers` files and auto-selects one, warning in
//! chat if multiple stacks matched.  With `--stack`, the named stack is used
//! unconditionally.
//!
//! Stack images follow the naming convention `huskies-project-<stack>`.
//! The base image (no language tooling) is `huskies-project-base`.
//!
//! Adding a new stack requires only:
//! 1. `docker/stacks/<name>/Dockerfile.fragment` — overlay instructions
//! 2. `docker/stacks/<name>/markers` — detection marker filenames
//! No changes to this orchestration module are needed.

use std::collections::BTreeMap;
use std::path::Path;
use std::sync::Arc;
use tokio::sync::RwLock;

use crate::service::gateway::config::ProjectEntry;

/// Parsed result of a `new project <name> [--stack <stack>]` chat command.
pub struct NewProjectCommand {
    /// Project name (alphanumeric, hyphens, underscores).
    pub name: String,
    /// Explicitly requested stack, or `None` for auto-detection.
    pub stack: Option<String>,
}

/// Parse a `new project <name> [--stack <stack>]` command from a chat message.
///
/// Returns `Some(NewProjectCommand)` when the stripped message starts with
/// "new project" (case-insensitive). An empty name (bare "new project" with
/// no arg) is returned as `Some(name="")` so the handler can emit a usage
/// error. Returns `None` for any other message.
pub fn extract_new_project_command(
    message: &str,
    bot_name: &str,
    bot_user_id: &str,
) -> Option<NewProjectCommand> {
    let mention_stripped = crate::chat::util::strip_bot_mention(message, bot_name, bot_user_id);
    // Strip leading punctuation (e.g. colon after "@timmy: new project …")
    let trimmed = mention_stripped
        .trim()
        .trim_start_matches(|c: char| !c.is_alphanumeric());

    let mut words = trimmed.split_whitespace();
    let first = words.next()?;
    if !first.eq_ignore_ascii_case("new") {
        return None;
    }
    let second = words.next()?;
    if !second.eq_ignore_ascii_case("project") {
        return None;
    }
    let name = words.next().unwrap_or("").to_string();

    // Scan remaining tokens for `--stack <value>`.
    let remaining: Vec<&str> = words.collect();
    let stack = parse_stack_flag(&remaining);

    Some(NewProjectCommand { name, stack })
}

/// Extract the value of `--stack <value>` from a token slice.
fn parse_stack_flag(tokens: &[&str]) -> Option<String> {
    let mut iter = tokens.iter().peekable();
    while let Some(tok) = iter.next() {
        if *tok == "--stack"
            && let Some(val) = iter.next()
        {
            return Some(val.to_string());
        }
    }
    None
}

/// Scan `stacks_dir` for per-stack `markers` files and detect which stacks
/// match the given project directory.
///
/// Returns `(selected_stack, warnings)` where `selected_stack` is the
/// auto-detected stack name (or `None` if no markers matched) and `warnings`
/// carries a human-readable message when multiple stacks matched.
///
/// Each `stacks_dir/<name>/markers` file lists one filename per line
/// (relative to the project root). Lines starting with `#` and blank lines
/// are ignored. If any listed file exists in `project_path`, that stack is
/// considered a match.
pub fn detect_stack(project_path: &Path, stacks_dir: &Path) -> (Option<String>, Vec<String>) {
    let entries = match std::fs::read_dir(stacks_dir) {
        Ok(e) => e,
        Err(_) => return (None, vec![]),
    };

    // (stack_name, number_of_matched_marker_files)
    let mut matched: Vec<(String, usize)> = Vec::new();

    let mut stack_dirs: Vec<_> = entries
        .filter_map(|e| e.ok())
        .filter(|e| e.path().is_dir())
        .collect();
    // Deterministic order so multi-match selection is stable.
    stack_dirs.sort_by_key(|e| e.file_name());

    for entry in stack_dirs {
        let stack_name = entry.file_name().to_string_lossy().into_owned();
        let markers_path = entry.path().join("markers");
        let Ok(content) = std::fs::read_to_string(&markers_path) else {
            continue;
        };
        let count = content
            .lines()
            .filter(|line| {
                let trimmed = line.trim();
                !trimmed.is_empty()
                    && !trimmed.starts_with('#')
                    && project_path.join(trimmed).exists()
            })
            .count();
        if count > 0 {
            matched.push((stack_name, count));
        }
    }

    match matched.len() {
        0 => (None, vec![]),
        1 => (Some(matched.remove(0).0), vec![]),
        _ => {
            // Dominant stack: most marker files matched; alphabetical tiebreak for stability.
            matched.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
            let names: Vec<String> = matched.iter().map(|(n, _)| n.clone()).collect();
            let names_str = names.join(", ");
            let chosen = matched.swap_remove(0).0;
            let warning = format!(
                "Multiple stacks detected ({names_str}); using **{chosen}** \
                 (most marker files matched). \
                 Pass `--stack <name>` to override."
            );
            (Some(chosen), vec![warning])
        }
    }
}

/// Return the Docker image name for the given stack.
///
/// Stack images follow the convention `huskies-project-<stack>`.
/// When no stack is specified, the base image `huskies-project-base` is used.
pub fn image_for_stack(stack: Option<&str>) -> String {
    match stack {
        Some(s) => format!("huskies-project-{s}"),
        None => "huskies-project-base".to_string(),
    }
}

/// Bootstrap a new project from the `new project <name> [--stack <stack>]` command.
///
/// Creates `~/huskies/<name>/`, scaffolds `.huskies/`, runs `git init`,
/// auto-detects or honours the requested stack, launches the appropriate
/// Docker container, and registers the project in both the gateway's
/// in-memory store and the CRDT.
///
/// On any failure after the host directory is created, the directory is removed
/// and the error message includes "Partial state removed at `<path>`".
pub async fn handle_new_project(
    name: &str,
    stack: Option<&str>,
    projects_store: &Arc<RwLock<BTreeMap<String, ProjectEntry>>>,
    config_dir: &Path,
) -> String {
    let name = name.trim();

    if name.is_empty() {
        return "Usage: `new project <name>` — e.g. `new project myapp`".to_string();
    }
    if !name
        .chars()
        .all(|c| c.is_alphanumeric() || c == '-' || c == '_')
    {
        return format!(
            "Invalid project name `{name}`. \
             Use letters, digits, hyphens, or underscores only."
        );
    }

    // Name conflict — check both the in-memory store and the CRDT.
    {
        let projects = projects_store.read().await;
        if projects.contains_key(name) {
            return format!(
                "Project `{name}` is already registered. \
                 Use `switch {name}` to activate it."
            );
        }
    }

    // Default host path: ~/huskies/<name>/
    let home = std::env::var("HOME").unwrap_or_else(|_| "/home/huskies".to_string());
    let host_path = std::path::PathBuf::from(home).join("huskies").join(name);

    if host_path.exists() {
        return format!(
            "Path `{}` already exists. \
             Choose a different project name or remove the directory first.",
            host_path.display()
        );
    }

    // ── Create host directory ────────────────────────────────────────────────

    if let Err(e) = crate::service::gateway::io::ensure_directory(&host_path) {
        return format!("Failed to create `{}`: {e}", host_path.display());
    }

    // ── Scaffold .huskies/ ───────────────────────────────────────────────────

    if let Err(e) = crate::service::gateway::io::scaffold_project(&host_path) {
        let _ = tokio::fs::remove_dir_all(&host_path).await;
        return format!(
            "Scaffold failed: {e}\n\nPartial state removed at `{}`.",
            host_path.display()
        );
    }
    crate::service::gateway::io::init_wizard_state(&host_path);

    // ── git init ─────────────────────────────────────────────────────────────

    match tokio::process::Command::new("git")
        .arg("init")
        .arg(&host_path)
        .output()
        .await
    {
        Err(e) => {
            let _ = tokio::fs::remove_dir_all(&host_path).await;
            return format!(
                "git init failed: {e}\n\nPartial state removed at `{}`.",
                host_path.display()
            );
        }
        Ok(out) if !out.status.success() => {
            let stderr = String::from_utf8_lossy(&out.stderr);
            let _ = tokio::fs::remove_dir_all(&host_path).await;
            return format!(
                "git init failed: {}\n\nPartial state removed at `{}`.",
                stderr.trim(),
                host_path.display()
            );
        }
        Ok(_) => {}
    }

    // ── Detect or validate stack ─────────────────────────────────────────────

    let stacks_dir = config_dir.join("docker").join("stacks");
    let (resolved_stack, detect_warnings) = match stack {
        Some(s) => (Some(s.to_string()), vec![]),
        None => detect_stack(&host_path, &stacks_dir),
    };
    let image = image_for_stack(resolved_stack.as_deref());

    // ── Allocate port and launch container ───────────────────────────────────

    let port = find_free_port(3100);
    let container_url = format!("http://127.0.0.1:{port}");
    let container_name = format!("huskies-{name}");

    let docker_result = tokio::process::Command::new("docker")
        .args([
            "run",
            "-d",
            "--name",
            &container_name,
            "-p",
            &format!("127.0.0.1:{port}:3001"),
            "-v",
            &format!("{}:/workspace", host_path.display()),
            "--restart",
            "unless-stopped",
            &image,
            "huskies",
            "/workspace",
        ])
        .output()
        .await;

    match docker_result {
        Ok(out) if out.status.success() => {
            // Register in the CRDT (survives restarts).
            crate::crdt_state::write_gateway_project(name, &container_url);

            // Update the in-memory projects store and persist to projects.toml.
            {
                let mut projects = projects_store.write().await;
                projects.insert(name.to_string(), ProjectEntry::with_url(&container_url));
                crate::service::gateway::io::save_config(&projects, config_dir).await;
            }

            crate::slog!(
                "[new-project] Created project '{name}' at {container_url} (image={image})"
            );

            let stack_note = match resolved_stack.as_deref() {
                Some(s) => format!("- Stack: **{s}** (`{image}`)\n"),
                None => String::new(),
            };
            let warning_block = if detect_warnings.is_empty() {
                String::new()
            } else {
                format!("\n> {}\n", detect_warnings.join("\n> "))
            };

            format!(
                "{warning_block}Project **{name}** is ready.\n\
                 - Host path: `{host}`\n\
                 - Container: `{container_name}` → `{container_url}`\n\
                 {stack_note}\
                 \n\
                 Use `switch {name}` then `status` to view the pipeline.",
                host = host_path.display()
            )
        }
        Ok(out) => {
            let stderr = String::from_utf8_lossy(&out.stderr);
            let _ = tokio::fs::remove_dir_all(&host_path).await;
            format!(
                "Docker container launch failed: {}\n\nPartial state removed at `{}`.",
                stderr.trim(),
                host_path.display()
            )
        }
        Err(e) => {
            let _ = tokio::fs::remove_dir_all(&host_path).await;
            format!(
                "Docker container launch failed: {e}\n\nPartial state removed at `{}`.",
                host_path.display()
            )
        }
    }
}

/// Find a free TCP port by attempting to bind starting from `start`.
///
/// Scans up to 100 ports above `start` and returns the first available one.
/// Falls back to `start` if none are found (unlikely in practice).
fn find_free_port(start: u16) -> u16 {
    for port in start..start + 100 {
        if std::net::TcpListener::bind(("127.0.0.1", port)).is_ok() {
            return port;
        }
    }
    start
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn extract_parses_name() {
        let cmd =
            extract_new_project_command("@timmy new project myapp", "Timmy", "@timmy:srv.local")
                .unwrap();
        assert_eq!(cmd.name, "myapp");
        assert_eq!(cmd.stack, None);
    }

    #[test]
    fn extract_case_insensitive() {
        let cmd =
            extract_new_project_command("@timmy NEW PROJECT myapp", "Timmy", "@timmy:srv.local")
                .unwrap();
        assert_eq!(cmd.name, "myapp");
    }

    #[test]
    fn extract_bare_project_keyword_returns_empty_name() {
        let cmd =
            extract_new_project_command("@timmy new project", "Timmy", "@timmy:srv.local").unwrap();
        assert_eq!(cmd.name, "");
    }

    #[test]
    fn extract_parses_stack_flag() {
        let cmd = extract_new_project_command(
            "@timmy new project myapp --stack rust",
            "Timmy",
            "@timmy:srv.local",
        )
        .unwrap();
        assert_eq!(cmd.name, "myapp");
        assert_eq!(cmd.stack, Some("rust".to_string()));
    }

    #[test]
    fn extract_stack_node() {
        let cmd = extract_new_project_command(
            "@timmy new project myapp --stack node",
            "Timmy",
            "@timmy:srv.local",
        )
        .unwrap();
        assert_eq!(cmd.stack, Some("node".to_string()));
    }

    #[test]
    fn extract_no_match_for_other_commands() {
        assert!(
            extract_new_project_command("@timmy status", "Timmy", "@timmy:srv.local").is_none()
        );
    }

    #[test]
    fn extract_no_match_when_second_word_is_not_project() {
        assert!(
            extract_new_project_command("@timmy new myapp", "Timmy", "@timmy:srv.local").is_none()
        );
    }

    #[test]
    fn extract_handles_extra_whitespace() {
        let cmd = extract_new_project_command(
            "@timmy   new   project   myapp",
            "Timmy",
            "@timmy:srv.local",
        )
        .unwrap();
        assert_eq!(cmd.name, "myapp");
    }

    #[test]
    fn image_for_stack_rust() {
        assert_eq!(image_for_stack(Some("rust")), "huskies-project-rust");
    }

    #[test]
    fn image_for_stack_node() {
        assert_eq!(image_for_stack(Some("node")), "huskies-project-node");
    }

    #[test]
    fn image_for_stack_base() {
        assert_eq!(image_for_stack(None), "huskies-project-base");
    }

    #[test]
    fn detect_stack_rust_marker() {
        let dir = tempfile::tempdir().unwrap();
        // Create a fake project with Cargo.toml
        std::fs::write(dir.path().join("Cargo.toml"), "[package]").unwrap();

        // Create a fake stacks dir
        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("rust")).unwrap();
        std::fs::write(
            stacks.path().join("rust/markers"),
            "# comment\nCargo.toml\n",
        )
        .unwrap();
        std::fs::create_dir_all(stacks.path().join("node")).unwrap();
        std::fs::write(
            stacks.path().join("node/markers"),
            "package.json\ntsconfig.json\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("rust".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_node_tsconfig() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("tsconfig.json"), "{}").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("node")).unwrap();
        std::fs::write(
            stacks.path().join("node/markers"),
            "package.json\ntsconfig.json\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("node".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_no_markers_returns_none() {
        let dir = tempfile::tempdir().unwrap();
        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("rust")).unwrap();
        std::fs::write(stacks.path().join("rust/markers"), "Cargo.toml\n").unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, None);
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_multiple_warn() {
        let dir = tempfile::tempdir().unwrap();
        // Both Cargo.toml and package.json exist.
        std::fs::write(dir.path().join("Cargo.toml"), "").unwrap();
        std::fs::write(dir.path().join("package.json"), "{}").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("node")).unwrap();
        std::fs::write(stacks.path().join("node/markers"), "package.json\n").unwrap();
        std::fs::create_dir_all(stacks.path().join("rust")).unwrap();
        std::fs::write(stacks.path().join("rust/markers"), "Cargo.toml\n").unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        // Alphabetically first: "node" < "rust"
        assert_eq!(stack, Some("node".to_string()));
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].contains("Multiple stacks"));
    }

    #[test]
    fn detect_stack_missing_stacks_dir_returns_none() {
        let dir = tempfile::tempdir().unwrap();
        let (stack, warnings) = detect_stack(dir.path(), Path::new("/nonexistent/stacks"));
        assert_eq!(stack, None);
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_go_mod() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("go.mod"), "module example").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("go")).unwrap();
        std::fs::write(stacks.path().join("go/markers"), "go.mod\n").unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("go".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_python_pyproject() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("pyproject.toml"), "[tool.poetry]").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("python")).unwrap();
        std::fs::write(
            stacks.path().join("python/markers"),
            "pyproject.toml\nrequirements.txt\nsetup.py\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("python".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_python_requirements_txt() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("requirements.txt"), "flask\n").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("python")).unwrap();
        std::fs::write(
            stacks.path().join("python/markers"),
            "pyproject.toml\nrequirements.txt\nsetup.py\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("python".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_python_setup_py() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("setup.py"), "from setuptools import setup").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("python")).unwrap();
        std::fs::write(
            stacks.path().join("python/markers"),
            "pyproject.toml\nrequirements.txt\nsetup.py\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("python".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_ruby_gemfile() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("Gemfile"), "source 'https://rubygems.org'").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("ruby")).unwrap();
        std::fs::write(stacks.path().join("ruby/markers"), "Gemfile\n").unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("ruby".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_jvm_pom_xml() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("jvm")).unwrap();
        std::fs::write(
            stacks.path().join("jvm/markers"),
            "pom.xml\nbuild.gradle\nbuild.gradle.kts\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("jvm".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_jvm_build_gradle() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("build.gradle"), "plugins { }").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("jvm")).unwrap();
        std::fs::write(
            stacks.path().join("jvm/markers"),
            "pom.xml\nbuild.gradle\nbuild.gradle.kts\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("jvm".to_string()));
        assert!(warnings.is_empty());
    }

    #[test]
    fn detect_stack_jvm_build_gradle_kts() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(dir.path().join("build.gradle.kts"), "plugins { }").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("jvm")).unwrap();
        std::fs::write(
            stacks.path().join("jvm/markers"),
            "pom.xml\nbuild.gradle\nbuild.gradle.kts\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        assert_eq!(stack, Some("jvm".to_string()));
        assert!(warnings.is_empty());
    }

    /// A polyglot repo with more Python markers than Node markers should prefer python.
    #[test]
    fn detect_stack_multiple_dominant_wins() {
        let dir = tempfile::tempdir().unwrap();
        // Two Python markers: pyproject.toml + requirements.txt
        std::fs::write(dir.path().join("pyproject.toml"), "").unwrap();
        std::fs::write(dir.path().join("requirements.txt"), "").unwrap();
        // One Node marker: package.json (e.g. for a build tool)
        std::fs::write(dir.path().join("package.json"), "{}").unwrap();

        let stacks = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(stacks.path().join("node")).unwrap();
        std::fs::write(
            stacks.path().join("node/markers"),
            "package.json\ntsconfig.json\n",
        )
        .unwrap();
        std::fs::create_dir_all(stacks.path().join("python")).unwrap();
        std::fs::write(
            stacks.path().join("python/markers"),
            "pyproject.toml\nrequirements.txt\nsetup.py\n",
        )
        .unwrap();

        let (stack, warnings) = detect_stack(dir.path(), stacks.path());
        // python matches 2 markers, node matches 1 — python should win.
        assert_eq!(stack, Some("python".to_string()));
        assert_eq!(warnings.len(), 1);
        assert!(warnings[0].contains("Multiple stacks"));
    }
}