Merge pull request #147 from codeflash-ai/feature/freshness-local-sync-v1

Apply fresh generations without overwriting local work

Author: Saga4

Cargo.lock

@@ -37,6 +37,27 @@ pub enum ConflictResolution {
     Edited(PathBuf),
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ThreeWayTextMerge {
+    Clean(String),
+    Conflict(String),
+}
+
+/// Deterministic line-oriented three-way merge for portable text payloads.
+/// Disjoint edits are combined; overlapping edits are returned with explicit
+/// conflict markers so callers can preserve the original local file instead.
+pub fn merge_text_with_base(base: &str, local: &str, remote: &str) -> ThreeWayTextMerge {
+    let merged = render_conflict_marker_body_with_base(base, local, remote);
+    if merged.contains(CONFLICT_LOCAL_MARKER)
+        && merged.contains(CONFLICT_SEPARATOR_MARKER)
+        && merged.contains(CONFLICT_REMOTE_MARKER)
+    {
+        ThreeWayTextMerge::Conflict(merged)
+    } else {
+        ThreeWayTextMerge::Clean(merged)
+    }
+}
+
 pub fn render_inline_conflict_markdown(
     local_contents: &str,
     remote_document: &CanonicalDocument,

crates/locality-core/src/conflict.rs

@@ -9,7 +9,16 @@ use std::fmt::{Display, Formatter};
 use std::path::{Component, PathBuf};
 use std::str::FromStr;
 
+use caseless::Caseless;
 use serde::{Deserialize, Deserializer, Serialize};
+use unicode_normalization_v16::UnicodeNormalization;
+
+/// Frozen ADR0005 portable filesystem ceilings. Both encodings are bounded so
+/// an accepted logical path is materializable on every supported host.
+pub const MAX_LOGICAL_PATH_COMPONENT_UTF8_BYTES: usize = 255;
+pub const MAX_LOGICAL_PATH_COMPONENT_UTF16_UNITS: usize = 255;
+pub const MAX_LOGICAL_PATH_UTF8_BYTES: usize = 1024;
+pub const MAX_LOGICAL_PATH_UTF16_UNITS: usize = 1024;
 
 use crate::model::{EntityKind, HydrationState, MountId, RemoteId, TreeEntry};
 use crate::planner::{
@@ -136,6 +145,29 @@ impl LogicalPath {
     pub fn to_relative_path_buf(&self) -> PathBuf {
         PathBuf::from(&self.0)
     }
+
+    /// ADR0005 portable filesystem collision key.
+    ///
+    /// Each component uses Unicode 16 full default non-Turkic case folding
+    /// followed by NFC. Separators remain structural, so this is safe to use
+    /// for whole-tree collision detection without consulting the host OS.
+    pub fn portable_collision_key(&self) -> String {
+        portable_path_collision_key(&self.0)
+    }
+}
+
+fn portable_path_collision_key(value: &str) -> String {
+    value
+        .split('/')
+        .map(|component| {
+            component
+                .chars()
+                .default_case_fold()
+                .nfc()
+                .collect::<String>()
+        })
+        .collect::<Vec<_>>()
+        .join("/")
 }
 
 impl Display for LogicalPath {
@@ -181,6 +213,9 @@ pub enum LogicalPathError {
     ReservedMetadata,
     ReservedName(String),
     UnsafeCharacter,
+    NotNfc(String),
+    ComponentTooLong(String),
+    PathTooLong,
 }
 
 impl Display for LogicalPathError {
@@ -206,6 +241,19 @@ impl Display for LogicalPathError {
             Self::UnsafeCharacter => {
                 formatter.write_str("logical path contains an unsafe character")
             }
+            Self::NotNfc(component) => {
+                write!(
+                    formatter,
+                    "logical path component is not NFC: `{component}`"
+                )
+            }
+            Self::ComponentTooLong(component) => {
+                write!(
+                    formatter,
+                    "logical path component exceeds ADR0005 limits: `{component}`"
+                )
+            }
+            Self::PathTooLong => formatter.write_str("logical path exceeds ADR0005 limits"),
         }
     }
 }
@@ -222,17 +270,36 @@ fn validate_logical_path(value: &str) -> Result<(), LogicalPathError> {
     if value.contains('\\') {
         return Err(LogicalPathError::Backslash);
     }
-    if value.eq_ignore_ascii_case(RESERVED_EXPORT_METADATA_PATH) {
+    if portable_path_collision_key(value)
+        == portable_path_collision_key(RESERVED_EXPORT_METADATA_PATH)
+    {
         return Err(LogicalPathError::ReservedMetadata);
     }
+    if value.len() > MAX_LOGICAL_PATH_UTF8_BYTES
+        || value.encode_utf16().count() > MAX_LOGICAL_PATH_UTF16_UNITS
+    {
+        return Err(LogicalPathError::PathTooLong);
+    }
 
     for (index, component) in value.split('/').enumerate() {
         if component.is_empty() || matches!(component, "." | "..") {
             return Err(LogicalPathError::NonNormalizedComponent(
                 component.to_string(),
             ));
         }
-        if component.chars().any(char::is_control) || component.contains(':') {
+        if component.nfc().ne(component.chars()) {
+            return Err(LogicalPathError::NotNfc(component.to_string()));
+        }
+        if component.len() > MAX_LOGICAL_PATH_COMPONENT_UTF8_BYTES
+            || component.encode_utf16().count() > MAX_LOGICAL_PATH_COMPONENT_UTF16_UNITS
+        {
+            return Err(LogicalPathError::ComponentTooLong(component.to_string()));
+        }
+        if component.chars().any(char::is_control)
+            || component
+                .chars()
+                .any(|character| matches!(character, '<' | '>' | ':' | '"' | '|' | '?' | '*'))
+        {
             if index == 0
                 && component.as_bytes().get(1) == Some(&b':')
                 && component.as_bytes()[0].is_ascii_alphabetic()
@@ -250,14 +317,20 @@ fn validate_logical_path(value: &str) -> Result<(), LogicalPathError> {
             .split_once('.')
             .map_or(component, |(stem, _)| stem)
             .to_ascii_lowercase();
-        if matches!(device_name.as_str(), "con" | "prn" | "aux" | "nul")
-            || device_name.strip_prefix("com").is_some_and(|suffix| {
-                matches!(suffix, "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9")
-            })
-            || device_name.strip_prefix("lpt").is_some_and(|suffix| {
-                matches!(suffix, "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9")
-            })
-        {
+        if matches!(
+            device_name.as_str(),
+            "con" | "prn" | "aux" | "nul" | "clock$" | "conin$" | "conout$"
+        ) || device_name.strip_prefix("com").is_some_and(|suffix| {
+            matches!(
+                suffix,
+                "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "¹" | "²" | "³"
+            )
+        }) || device_name.strip_prefix("lpt").is_some_and(|suffix| {
+            matches!(
+                suffix,
+                "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "¹" | "²" | "³"
+            )
+        }) {
             return Err(LogicalPathError::ReservedName(component.to_string()));
         }
     }
@@ -677,7 +750,13 @@ mod tests {
             "safe/./dot.md",
             ".loc/session.json",
             ".LOC/SESSION.JSON",
+            ".loc/ſession.json",
             "safe/NUL.txt",
+            "safe/COM¹.txt",
+            "safe/CONOUT$.log",
+            "safe/bad?.md",
+            "safe/bad|name.md",
+            "safe/e\u{301}.md",
         ];
 
         for value in cases {
@@ -688,6 +767,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn reserved_export_metadata_uses_the_full_adr0005_collision_key() {
+        assert_eq!(
+            LogicalPath::new(".loc/ſession.json"),
+            Err(LogicalPathError::ReservedMetadata)
+        );
+    }
+
+    #[test]
+    fn logical_path_enforces_utf8_and_utf16_adr0005_ceilings() {
+        assert!(LogicalPath::new("a".repeat(255)).is_ok());
+        assert!(matches!(
+            LogicalPath::new("a".repeat(256)),
+            Err(LogicalPathError::ComponentTooLong(_))
+        ));
+        assert!(matches!(
+            LogicalPath::new("😀".repeat(128)),
+            Err(LogicalPathError::ComponentTooLong(_))
+        ));
+        let long_path = vec!["a".repeat(255); 5].join("/");
+        assert_eq!(
+            LogicalPath::new(long_path),
+            Err(LogicalPathError::PathTooLong)
+        );
+    }
+
     #[test]
     fn logical_path_deserialization_revalidates_input() {
         let error = serde_json::from_str::<LogicalPath>(r#""../escape.md""#)