nmem-cli 0.10.7__tar.gz → 0.10.8__tar.gz

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/Cargo.lock

@@ -5206,7 +5206,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-cli"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anstyle",
  "anyhow",
@@ -5223,7 +5223,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-content"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "md5",
@@ -5235,7 +5235,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-core"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "serde",
  "serde_json",
@@ -5245,7 +5245,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-docs"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "criterion",
  "scraper",
@@ -5255,7 +5255,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-embed"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "arrow-array",
@@ -5275,7 +5275,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-feed"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -5284,7 +5284,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-graph"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "caseless",
@@ -5303,7 +5303,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-harness"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "futures",
@@ -5323,7 +5323,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-model"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "encoding_rs",
@@ -5352,7 +5352,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-search"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "arrow-array",
@@ -5374,7 +5374,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-server"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -5430,7 +5430,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-tui"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "arboard",
@@ -5444,7 +5444,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-websearch"
-version = "0.10.7"
+version = "0.10.8"
 dependencies = [
  "anyhow",
  "dom_smoothie",

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/nmem-cli"]
 
 [workspace.package]
 edition = "2021"
-version = "0.10.7"
+version = "0.10.8"
 license = "UNLICENSED"
 publish = false
 

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.10.7
+Version: 0.10.8
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/crates/nmem-cli/src/commands/session_import.rs

@@ -884,9 +884,62 @@ fn encode_claude_segment(segment: &str, dot_mode: &str) -> String {
     }
 }
 
+/// True for a Windows drive-letter absolute path (`C:\...`, `d:/...`).
+fn is_windows_drive_path(path: &str) -> bool {
+    let bytes = path.as_bytes();
+    bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':'
+}
+
+/// Claude Code's Windows directory-naming rule (observed on Windows): every
+/// special character in the absolute path is replaced with a single `-`, with
+/// NO leading `-` (the path already starts with a drive letter). The drive
+/// colon and the trailing separator each map to their own `-`, hence the
+/// characteristic double dash after the drive letter:
+///   `D:\`                        -> `D--`   (`:` -> `-`, `\` -> `-`)
+///   `D:\server-prod-env-setting` -> `D--server-prod-env-setting`
+///   `D:\a\b`                     -> `D--a-b`
+/// See `.context/attachments/.../claude-code-nmem-stop-hook-bug.md`.
+fn encode_claude_windows_project_path(project_path: &str) -> String {
+    project_path
+        .chars()
+        .map(|c| match c {
+            '\\' | '/' | ':' | '.' | '_' => '-',
+            other => other,
+        })
+        .collect()
+}
+
+/// Historical single-dash Windows slug: collapse each RUN of special chars to
+/// one `-` (so the drive `:` + `\` becomes a single dash). Used only as a
+/// migration fallback when the correct double-dash dir is absent:
+///   `D:\server-prod-env-setting` -> `D-server-prod-env-setting`
+fn encode_claude_windows_project_path_single_dash(project_path: &str) -> String {
+    let mut out = String::with_capacity(project_path.len());
+    let mut prev_dash = false;
+    for c in project_path.chars() {
+        if matches!(c, '\\' | '/' | ':' | '.' | '_') {
+            if !prev_dash {
+                out.push('-');
+                prev_dash = true;
+            }
+        } else {
+            out.push(c);
+            prev_dash = false;
+        }
+    }
+    out
+}
+
 fn encode_claude_project_path(project_path: &str, dot_mode: &str) -> String {
-    // Windows drive form (C:\...) is not handled on this POSIX-focused port;
-    // the desktop bundle covers Windows hosts.
+    // Windows drive paths (`C:\...`) follow Claude Code's own slug rule, which
+    // differs from POSIX: no leading `-`, and the drive `:` becomes its own `-`
+    // (producing the `D--...` double-dash form). The POSIX segment logic below
+    // can't reproduce that because it always prepends a leading `-` and never
+    // touches the drive colon. `dot_mode` is irrelevant for the drive form:
+    // Claude Code maps every special char (including `.`/`_`) to one `-`.
+    if is_windows_drive_path(project_path) {
+        return encode_claude_windows_project_path(project_path);
+    }
     let segments: Vec<String> = project_path
         .replace('\\', "/")
         .split('/')
@@ -993,11 +1046,19 @@ fn resolve_claude_project_dir(project_path: &str) -> Option<PathBuf> {
     let variants = project_path_variants(project_path);
     let mut candidate_dirs: Vec<PathBuf> = Vec::new();
     for variant in &variants {
-        for encoded in [
+        let mut encodings = vec![
             encode_claude_project_path(variant, "all_as_hyphen"),
             encode_claude_project_path(variant, "hidden_only"),
             encode_claude_project_path(variant, "preserve"),
-        ] {
+        ];
+        // Historical single-dash Windows slug (`D-server-...`): older components
+        // collapsed the drive `:` + separator run into one `-`, so a user
+        // mid-migration may still have transcripts under the single-dash dir.
+        // The double-dash form is primary; this only adds a fallback candidate.
+        if is_windows_drive_path(variant) {
+            encodings.push(encode_claude_windows_project_path_single_dash(variant));
+        }
+        for encoded in encodings {
             let candidate = claude_projects_dir.join(&encoded);
             if !candidate_dirs.contains(&candidate) {
                 candidate_dirs.push(candidate);
@@ -1632,9 +1693,46 @@ fn get_cursor_projects_dir() -> PathBuf {
 
 fn encode_cursor_project_path(project_path: &str) -> String {
     let normalized = normpath(&expanduser(project_path).to_string_lossy());
+    // Windows drive paths (`C:\...`, `C:/...`) follow Cursor's own dir-naming
+    // rule, which differs from POSIX: the drive `:` + separator collapses to a
+    // double dash and remaining separators each become one `-`, with no leading
+    // `-` (the encoded name starts with the drive letter). Mirrors the Python
+    // `_encode_cursor_project_path` win32 branch (`":\\" -> "--"`, `"\\" -> "-"`):
+    //   C:\Users\me\proj -> C--Users-me-proj
+    //   C:/a/b           -> C--a-b
+    // `normpath` above only collapses `/`, so a Windows path is untouched by it;
+    // detect the drive form here and slug both separators. Require a real
+    // separator after the drive colon (mirrors the Python `":\\" in ...` guard),
+    // so a bare `C:` never produces a stray trailing dash.
+    if is_windows_drive_path(&normalized)
+        && matches!(normalized.as_bytes().get(2), Some(b'\\') | Some(b'/'))
+    {
+        return encode_cursor_windows_project_path(&normalized);
+    }
     normalized.trim_start_matches('/').replace('/', "-")
 }
 
+/// Cursor's Windows dir-naming rule: `<drive>:<sep><rest>` becomes
+/// `<drive>--<rest with each `\`/`/` mapped to `-`>`. Pure/cross-platform so it
+/// unit-tests on any host. Mirrors the Python win32 branch exactly.
+fn encode_cursor_windows_project_path(normalized: &str) -> String {
+    // `is_windows_drive_path` guarantees bytes[0] is the drive letter and
+    // bytes[1] == ':'. Everything after the colon is the rest (which begins with
+    // a separator for an absolute drive path). Map the leading `:`+sep to `--`
+    // and any further separator to a single `-`.
+    let drive = &normalized[..1];
+    let after_colon = &normalized[2..]; // skip "<drive>:"
+    let rest: String = after_colon
+        .chars()
+        .map(|c| if c == '\\' || c == '/' { '-' } else { c })
+        .collect();
+    // `after_colon` starts with a separator for `C:\...`, which the map turns
+    // into a leading `-`; combined with the `-` we prepend, that yields the
+    // characteristic `--` after the drive letter. For the bare drive `C:` (no
+    // trailing separator) there is no leading separator, so emit a single `-`.
+    format!("{drive}-{rest}")
+}
+
 fn cursor_project_name(project_encoded: Option<&str>) -> Option<String> {
     let enc = project_encoded?;
     let parts: Vec<&str> = enc.split('-').filter(|p| !p.is_empty()).collect();
@@ -4848,6 +4946,76 @@ mod tests {
         );
     }
 
+    #[test]
+    fn claude_encode_windows_drive_double_dash() {
+        // Claude Code's real Windows dir rule: every special char -> one `-`,
+        // no leading `-`. The drive `:` + separator produce the double dash.
+        // dot_mode must be irrelevant for the drive form.
+        for mode in ["all_as_hyphen", "hidden_only", "preserve"] {
+            assert_eq!(encode_claude_project_path("D:\\", mode), "D--", "mode={mode}");
+            assert_eq!(
+                encode_claude_project_path("D:\\server-prod-env-setting", mode),
+                "D--server-prod-env-setting",
+                "mode={mode}"
+            );
+            assert_eq!(encode_claude_project_path("D:\\a\\b", mode), "D--a-b", "mode={mode}");
+            // Forward-slash drive form is equivalent.
+            assert_eq!(encode_claude_project_path("C:/a/b", mode), "C--a-b", "mode={mode}");
+        }
+        // POSIX path must keep the leading `-` and existing dot handling.
+        assert_eq!(
+            encode_claude_project_path("/Users/x/proj", "all_as_hyphen"),
+            "-Users-x-proj"
+        );
+    }
+
+    #[test]
+    fn claude_windows_single_dash_migration_variant() {
+        assert_eq!(
+            encode_claude_windows_project_path_single_dash("D:\\server-prod-env-setting"),
+            "D-server-prod-env-setting"
+        );
+        assert_eq!(
+            encode_claude_windows_project_path_single_dash("D:\\"),
+            "D-"
+        );
+        assert_eq!(
+            encode_claude_windows_project_path_single_dash("D:\\a\\b"),
+            "D-a-b"
+        );
+    }
+
+    #[test]
+    fn cursor_encode_windows_drive_double_dash() {
+        // Cursor's real Windows dir rule (Python `_encode_cursor_project_path`
+        // win32 branch): drive `:`+sep -> `--`, remaining sep -> `-`, no leading
+        // `-`. Pure transform, so it must produce the right slug on any host.
+        assert_eq!(
+            encode_cursor_windows_project_path("C:\\Users\\me\\proj"),
+            "C--Users-me-proj"
+        );
+        assert_eq!(encode_cursor_windows_project_path("D:\\a\\b"), "D--a-b");
+        // Forward-slash drive form is equivalent (normpath leaves `\` alone but
+        // a `/`-style Windows input can still reach here).
+        assert_eq!(encode_cursor_windows_project_path("C:/a/b"), "C--a-b");
+        // The public entrypoint routes drive paths through the Windows branch
+        // and POSIX paths through the original slug (leading `-` stripped).
+        assert_eq!(
+            encode_cursor_project_path("C:\\Users\\me\\proj"),
+            "C--Users-me-proj"
+        );
+        assert_eq!(encode_cursor_project_path("/Users/me/proj"), "Users-me-proj");
+    }
+
+    #[test]
+    fn detects_windows_drive_paths() {
+        assert!(is_windows_drive_path("D:\\"));
+        assert!(is_windows_drive_path("c:/x"));
+        assert!(!is_windows_drive_path("/Users/x"));
+        assert!(!is_windows_drive_path("relative/path"));
+        assert!(!is_windows_drive_path("."));
+    }
+
     #[test]
     fn sanitize_lowercases_and_replaces() {
         assert_eq!(sanitize_session_id("Sess_ABC 123!"), "sess_abc-123-");

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/crates/nmem-cli/src/commands/threads.rs

@@ -1048,7 +1048,35 @@ fn abs_lexical(project: &str) -> String {
             .unwrap_or_default()
             .join(expanded)
     };
-    abs.to_string_lossy().to_string()
+    // `PathBuf::join(".")` does not normalize, so `abs_lexical(".")` on Windows
+    // yields `D:\.` (a trailing `.` component). That trailing dot then slugs
+    // wrong (an extra separator in the Claude Code dir name). Strip a trailing
+    // `.` component lexically, honoring both separators. `current_dir()` is
+    // already canonical, so this only removes the artifact introduced by joining
+    // the literal default ".".
+    let s = abs.to_string_lossy().to_string();
+    strip_trailing_dot_component(&s)
+}
+
+/// Remove a trailing `\.` or `/.` (a no-op `.` path component) without touching
+/// the rest of the string. `D:\.` -> `D:\`, `/a/b/.` -> `/a/b`, `D:\` -> `D:\`.
+fn strip_trailing_dot_component(path: &str) -> String {
+    if let Some(stripped) = path.strip_suffix('.') {
+        // Only strip if the `.` is its own component (preceded by a separator),
+        // never a real name like `foo.` or the parent of `..`.
+        if stripped.ends_with(['/', '\\']) {
+            let trimmed = stripped.trim_end_matches(['/', '\\']);
+            // Keep the root separator: `/.` -> `/`, `D:\.` -> `D:\`.
+            if trimmed.is_empty() {
+                return "/".to_string();
+            }
+            if trimmed.ends_with(':') {
+                return format!("{trimmed}\\");
+            }
+            return trimmed.to_string();
+        }
+    }
+    path.to_string()
 }
 
 /// `os.path.basename(path.rstrip('/'))`.
@@ -2034,8 +2062,8 @@ fn urlencode(s: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::{
-        is_simple_message_list, sync_persistence_source, thread_authorship_metadata, urlencode,
-        with_stable_external_ids,
+        is_simple_message_list, strip_trailing_dot_component, sync_persistence_source,
+        thread_authorship_metadata, urlencode, with_stable_external_ids,
     };
     use serde_json::json;
 
@@ -2045,6 +2073,19 @@ mod tests {
         assert_eq!(urlencode("codex-019e95ac"), "codex-019e95ac");
     }
 
+    #[test]
+    fn strip_trailing_dot_component_removes_join_artifact() {
+        // `abs_lexical(".")` -> `cwd + "\."` on Windows; the trailing `.` must go.
+        assert_eq!(strip_trailing_dot_component("D:\\."), "D:\\");
+        assert_eq!(strip_trailing_dot_component("D:\\proj\\."), "D:\\proj");
+        assert_eq!(strip_trailing_dot_component("/a/b/."), "/a/b");
+        assert_eq!(strip_trailing_dot_component("/."), "/");
+        // Never touch real names ending in a dot or `..`.
+        assert_eq!(strip_trailing_dot_component("D:\\foo."), "D:\\foo.");
+        assert_eq!(strip_trailing_dot_component("D:\\proj"), "D:\\proj");
+        assert_eq!(strip_trailing_dot_component("/a/b"), "/a/b");
+    }
+
     #[test]
     fn authorship_explicit_wins_and_source_app_is_provenance() {
         // Use a source_app that is also a valid identity-looking string to prove

{nmem_cli-0.10.7 → nmem_cli-0.10.8}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "maturin"
 
 [project]
 name = "nmem-cli"
-version = "0.10.7"
+version = "0.10.8"
 description = "CLI and TUI for Nowledge Mem - AI memory management"
 authors = [
     { name = "Nowledge Labs" },