huskies: merge 844

server/src/crdt_state/write/migrations.rs

@@ -0,0 +1,182 @@
+//! Name and story-ID migration helpers for pipeline items.
+//!
+//! Contains one-time startup migrations that backfill the `name` field from
+//! story ID slugs and rewrite slug-form story IDs to numeric-only form.
+
+use bft_json_crdt::json_crdt::{CrdtNode, JsonValue};
+
+use super::super::state::{apply_and_persist, get_crdt, rebuild_index};
+use crate::slog;
+
+/// Derive a human-readable name from a story ID's slug component.
+///
+/// Strips the numeric prefix and item-type prefix (story/bug/spike/refactor),
+/// replaces underscores with spaces, and capitalises the first letter.
+///
+/// Examples:
+/// - `"729_story_store_story_name"` → `"Store story name"`
+/// - `"4_bug_login_crash"` → `"Login crash"`
+/// - `"10_spike_arch_review"` → `"Arch review"`
+pub fn name_from_story_id(story_id: &str) -> String {
+    // Strip the leading digits then the first underscore: "729_story_..." → "story_..."
+    let after_num = story_id.trim_start_matches(|c: char| c.is_ascii_digit());
+    let after_num = after_num.strip_prefix('_').unwrap_or(after_num);
+
+    // Strip the item-type prefix.
+    let slug = after_num
+        .strip_prefix("story_")
+        .or_else(|| after_num.strip_prefix("bug_"))
+        .or_else(|| after_num.strip_prefix("spike_"))
+        .or_else(|| after_num.strip_prefix("refactor_"))
+        .unwrap_or(after_num);
+
+    // Replace underscores with spaces.
+    let spaced = slug.replace('_', " ");
+
+    // Capitalise the first character.
+    let mut chars = spaced.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => {
+            let mut name = first.to_uppercase().to_string();
+            name.push_str(chars.as_str());
+            name
+        }
+    }
+}
+
+/// Extract the numeric-only ID from a slug-form story ID, if applicable.
+///
+/// Returns `Some("664")` for `"664_story_my_feature"`, and `None` for IDs
+/// that are already numeric-only (`"664"`) or have no valid numeric prefix.
+pub(super) fn numeric_id_from_slug(story_id: &str) -> Option<String> {
+    // Already numeric-only — no migration needed.
+    if story_id.chars().all(|c: char| c.is_ascii_digit()) {
+        return None;
+    }
+    // Must have a non-empty numeric segment before the first underscore.
+    let idx = story_id.find('_')?;
+    let prefix = &story_id[..idx];
+    if prefix.is_empty() || !prefix.chars().all(|c| c.is_ascii_digit()) {
+        return None;
+    }
+    Some(prefix.to_string())
+}
+
+/// Migrate existing story IDs from slug form (`664_story_my_feature`) to
+/// numeric-only form (`664`) in the in-memory CRDT, persisting a signed op
+/// for each updated register so the change survives restarts.
+///
+/// Returns the list of `(old_id, new_id)` pairs that were actually migrated.
+/// Callers should use this list to rename downstream filesystem artifacts
+/// (worktree directories, git branches, log directories).
+///
+/// Items whose `story_id` is already numeric-only are left untouched.
+/// Items where the target numeric ID is already in use are skipped to avoid
+/// conflicts.  Running this migration repeatedly is safe — subsequent calls
+/// on already-migrated state are no-ops.
+pub fn migrate_story_ids_to_numeric() -> Vec<(String, String)> {
+    let Some(state_mutex) = get_crdt() else {
+        return Vec::new();
+    };
+
+    // First pass: collect (index, old_id, new_id) while holding the lock.
+    let migrations: Vec<(usize, String, String)> = {
+        let Ok(state) = state_mutex.lock() else {
+            return Vec::new();
+        };
+
+        let existing_ids: std::collections::HashSet<String> = state.index.keys().cloned().collect();
+
+        state
+            .index
+            .iter()
+            .filter_map(|(story_id, &idx)| {
+                let numeric = numeric_id_from_slug(story_id)?;
+                // Skip if the target numeric ID is already occupied.
+                if existing_ids.contains(&numeric) {
+                    return None;
+                }
+                Some((idx, story_id.clone(), numeric))
+            })
+            .collect()
+    };
+
+    if migrations.is_empty() {
+        return Vec::new();
+    }
+
+    // Second pass: apply story_id register updates.
+    let Ok(mut state) = state_mutex.lock() else {
+        return Vec::new();
+    };
+
+    let mut result = Vec::new();
+    for (idx, old_id, new_id) in migrations {
+        apply_and_persist(&mut state, |s| {
+            s.crdt.doc.items[idx].story_id.set(new_id.clone())
+        });
+        result.push((old_id, new_id));
+    }
+
+    // Rebuild the index so all downstream reads use the new numeric IDs.
+    state.index = rebuild_index(&state.crdt);
+
+    let count = result.len();
+    slog!("[crdt] Migrated {count} story IDs from slug form to numeric");
+    result
+}
+
+/// Backfill the `name` CRDT field for pipeline items that have an empty name.
+///
+/// Iterates over all items in the in-memory CRDT.  For each item whose `name`
+/// register is empty, derives a human-readable name from the story ID slug
+/// (see [`name_from_story_id`]) and writes it via a signed CRDT op.
+///
+/// This is a one-time startup migration: items created before the `name` field
+/// was consistently populated will gain a name on the next server start.
+/// Items that already have a non-empty name are left untouched.
+pub fn migrate_names_from_slugs() {
+    let Some(state_mutex) = get_crdt() else {
+        return;
+    };
+
+    // First pass: collect (index, derived_name) pairs for items missing a name.
+    let migrations: Vec<(usize, String)> = {
+        let Ok(state) = state_mutex.lock() else {
+            return;
+        };
+        state
+            .index
+            .iter()
+            .filter_map(|(story_id, &idx)| {
+                let item = &state.crdt.doc.items[idx];
+                // Skip items that already have a name.
+                let already_named =
+                    matches!(item.name.view(), JsonValue::String(ref s) if !s.is_empty());
+                if already_named {
+                    return None;
+                }
+                let name = name_from_story_id(story_id);
+                if name.is_empty() {
+                    return None;
+                }
+                Some((idx, name))
+            })
+            .collect()
+    };
+
+    if migrations.is_empty() {
+        return;
+    }
+
+    // Second pass: apply all name writes while holding the lock.
+    let Ok(mut state) = state_mutex.lock() else {
+        return;
+    };
+    let count = migrations.len();
+    for (idx, name) in migrations {
+        apply_and_persist(&mut state, |s| s.crdt.doc.items[idx].name.set(name.clone()));
+    }
+    slog!("[crdt] Migrated names for {count} items from story ID slugs");
+}