@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-core/src/route/worktree_files.rs

@@ -0,0 +1,32 @@
+use std::fs;
+use std::path::Path;
+
+use crate::install_plan::{LOCAL_NATIVE_BINARY_PATHS, LOCAL_ONLY_MACHINE_OWNED_PATHS};
+use crate::models::NaomeError;
+
+pub(super) fn copy_local_harness_files(
+    source_root: &Path,
+    worktree_root: &Path,
+) -> Result<(), NaomeError> {
+    let mut paths = Vec::new();
+    paths.extend_from_slice(LOCAL_ONLY_MACHINE_OWNED_PATHS);
+    paths.extend_from_slice(LOCAL_NATIVE_BINARY_PATHS);
+
+    for relative_path in paths {
+        if relative_path == ".naome/archive" || relative_path == ".naome/task-journal.jsonl" {
+            continue;
+        }
+
+        let source = source_root.join(relative_path);
+        if !source.is_file() {
+            continue;
+        }
+        let destination = worktree_root.join(relative_path);
+        if let Some(parent) = destination.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::copy(&source, &destination)?;
+    }
+
+    Ok(())
+}

package/crates/naome-core/src/route/worktree_plan.rs

@@ -0,0 +1,131 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use crate::models::NaomeError;
+use crate::route::{
+    git_ops::{command_output, git_output},
+    MAX_NAOME_TASK_WORKTREES,
+};
+
+pub(super) struct WorktreePlan {
+    pub(super) base: PathBuf,
+    pub(super) slug: String,
+    pub(super) short_head: String,
+}
+
+pub(super) struct WorktreeCandidate {
+    pub(super) path: PathBuf,
+    pub(super) branch: String,
+}
+
+pub(super) fn worktree_plan(
+    root: &Path,
+    prompt: &str,
+    name_head: &str,
+) -> Result<WorktreePlan, NaomeError> {
+    let common_git_dir = git_common_dir(root)?;
+    let base = common_git_dir.join("naome").join("worktrees");
+    fs::create_dir_all(&base)?;
+    let worktree_count = existing_naome_task_worktree_count(&base)?;
+    if worktree_count >= MAX_NAOME_TASK_WORKTREES {
+        return Err(NaomeError::new(format!(
+            "Too many NAOME task worktrees are present ({worktree_count}). Finish or remove old task worktrees before creating another isolated task worktree."
+        )));
+    }
+
+    Ok(WorktreePlan {
+        base,
+        slug: prompt_slug(prompt),
+        short_head: name_head.chars().take(12).collect(),
+    })
+}
+
+pub(super) fn available_worktree_candidates(
+    root: &Path,
+    plan: &WorktreePlan,
+) -> Result<Vec<WorktreeCandidate>, NaomeError> {
+    let mut candidates = Vec::new();
+    for attempt in 1..100 {
+        let suffix = if attempt == 1 {
+            String::new()
+        } else {
+            format!("-{attempt}")
+        };
+        let name = format!("{}-{}{}", plan.slug, plan.short_head, suffix);
+        let branch = format!("naome/task/{name}");
+        let path = plan.base.join(&name);
+        if !path.exists() && !git_branch_exists(root, &branch)? {
+            candidates.push(WorktreeCandidate { path, branch });
+            return Ok(candidates);
+        }
+    }
+
+    Err(NaomeError::new(
+        "Cannot create a unique NAOME task worktree after 99 attempts.",
+    ))
+}
+
+fn existing_naome_task_worktree_count(worktree_base: &Path) -> Result<usize, NaomeError> {
+    let mut count = 0;
+    for entry in fs::read_dir(worktree_base)? {
+        let entry = entry?;
+        if entry.file_type()?.is_dir() {
+            count += 1;
+        }
+    }
+    Ok(count)
+}
+
+fn git_common_dir(root: &Path) -> Result<PathBuf, NaomeError> {
+    let output = git_output(root, &["rev-parse", "--git-common-dir"])?;
+    if !output.status.success() {
+        return Err(NaomeError::new(command_output(&output)));
+    }
+
+    let value = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    let path = PathBuf::from(value);
+    if path.is_absolute() {
+        Ok(path)
+    } else {
+        Ok(root.join(path))
+    }
+}
+
+fn git_branch_exists(root: &Path, branch: &str) -> Result<bool, NaomeError> {
+    let ref_name = format!("refs/heads/{branch}");
+    let output = Command::new("git")
+        .args(["show-ref", "--verify", "--quiet", &ref_name])
+        .current_dir(root)
+        .output()?;
+    match output.status.code() {
+        Some(0) => Ok(true),
+        Some(1) => Ok(false),
+        _ => Err(NaomeError::new(command_output(&output))),
+    }
+}
+
+fn prompt_slug(prompt: &str) -> String {
+    let mut slug = String::new();
+    let mut previous_dash = false;
+    for character in prompt.chars().flat_map(char::to_lowercase) {
+        if character.is_ascii_alphanumeric() {
+            slug.push(character);
+            previous_dash = false;
+        } else if !previous_dash && !slug.is_empty() {
+            slug.push('-');
+            previous_dash = true;
+        }
+
+        if slug.len() >= 40 {
+            break;
+        }
+    }
+
+    let slug = slug.trim_matches('-').to_string();
+    if slug.is_empty() {
+        "task".to_string()
+    } else {
+        slug
+    }
+}