diff --git a/mempalace/hooks_cli.py b/mempalace/hooks_cli.py index b8d07e0..be419f7 100644 --- a/mempalace/hooks_cli.py +++ b/mempalace/hooks_cli.py @@ -670,36 +670,124 @@ def _parse_harness_input(data: dict, harness: str) -> dict: } +# Common parent-dir tokens stripped from the encoded folder when no +# explicit ``-Projects-`` segment is present. Order matters: only the +# first match strips. These cover the bulk of Unix layouts; cwd-from-JSONL +# (the primary path) handles the long tail correctly without heuristics. +_ENCODED_PARENT_PREFIXES = ( + "git-", + "dev-", + "projects-", + "Projects-", + "src-", + "code-", + "work-", + "Documents-", +) + + +def _wing_from_jsonl_cwd(transcript_path: str) -> Optional[str]: + """Read ``cwd`` from the first JSONL line that records it. + + Claude Code stores the absolute working directory on most message + types (tool_use, tool_result, user/assistant turns), but not all + (e.g. queue-operation lines lack it). Scan up to 200 lines to find + the first record that includes a non-empty cwd, then derive the + wing from its leaf path segment. Returns ``None`` if the file is + unreadable, empty, or contains no cwd. + """ + try: + path = Path(transcript_path).expanduser() + if not path.is_file(): + return None + with path.open("r", encoding="utf-8", errors="replace") as f: + for i, line in enumerate(f): + if i >= 200: + break + line = line.strip() + if not line or '"cwd"' not in line: + continue + try: + data = json.loads(line) + except (json.JSONDecodeError, ValueError): + continue + cwd = data.get("cwd") + if not cwd or not isinstance(cwd, str): + continue + cwd_norm = cwd.replace("\\", "/").rstrip("/") + if not cwd_norm: + continue + project = cwd_norm.rsplit("/", 1)[-1] + if project: + slug = project.lower().replace(" ", "_").replace("-", "_") + return f"wing_{slug}" + except OSError: + pass + return None + + def _wing_from_transcript_path(transcript_path: str) -> str: """Derive a project wing name from a Claude Code transcript path. - Claude Code encodes the project's source directory by replacing path - separators with dashes, producing folders like: - ~/.claude/projects/-home--Projects-/session.jsonl - ~/.claude/projects/-home--dev--/session.jsonl - ~/.claude/projects/-Users---/session.jsonl + Strategy (in priority order): - The project directory name is the final dash-separated token of the - encoded folder. Returns ``wing_`` (lowercased, spaces → ``_``). - Falls back to ``wing_sessions`` if the path does not match a Claude Code - project-folder layout. + 1. PRIMARY — Read ``cwd`` from the JSONL transcript. Claude Code records + the absolute working directory on most message types, so the project + name is whatever the leaf path segment of cwd is. This is the + canonical answer when present. + + 2. FALLBACK — Decode the encoded folder under ``.claude/projects/``. + Claude Code flattens path separators to dashes (``/Users/me/code/foo`` + → ``-Users-me-code-foo``), so the original directory boundaries are + lost. We strip the platform user-home prefix (``Users--`` or + ``home--``) and one common parent-dir token (``git-``, ``dev-``, + ``projects-``, etc.), then convert the remaining dashes to + underscores. Unlike the previous "last token only" heuristic, this + never silently truncates a hyphenated project folder name like + ``claude-code``, ``react-native``, or ``customer-portal``. + + 3. LEGACY — Match an explicit ``-Projects-`` segment for + transcripts not under the standard Claude Code projects dir. + + 4. DEFAULT — ``wing_sessions``. + + Closes #1410. """ + # 1. Primary — cwd from JSONL is the canonical source of truth + cwd_wing = _wing_from_jsonl_cwd(transcript_path) + if cwd_wing: + return cwd_wing + # Normalize path separators for cross-platform (Windows backslashes) normalized = transcript_path.replace("\\", "/") - # Primary: pull the encoded project folder out of ``.claude/projects/`` - # and take its last dash-separated token. + + # 2. Fallback — encoded project folder under .claude/projects/ match = re.search(r"/\.claude/projects/-([^/]+)", normalized) if match: encoded = match.group(1) - project = encoded.rsplit("-", 1)[-1] + # Strip platform user-home prefix so the wing isn't dominated by + # /Users// or /home//. + m = re.match(r"(?:Users|home)-[^-]+-(.+)", encoded) + if m: + encoded = m.group(1) + # Strip one common parent-dir token if present, keeping the rest as + # the project path. Hyphens become underscores to preserve + # uniqueness for hyphenated project folder names. + for prefix in _ENCODED_PARENT_PREFIXES: + if encoded.startswith(prefix): + encoded = encoded[len(prefix) :] + break + project = encoded.lower().replace(" ", "_").replace("-", "_") if project: - return f"wing_{project.lower().replace(' ', '_')}" - # Legacy fallback: explicit ``-Projects-`` segment, useful for - # transcripts not under the standard Claude Code projects dir. + return f"wing_{project}" + + # 3. Legacy — explicit -Projects- segment match = re.search(r"-Projects-([^/]+?)(?:/|$)", normalized) if match: - project = match.group(1).lower().replace(" ", "_") + project = match.group(1).lower().replace(" ", "_").replace("-", "_") return f"wing_{project}" + + # 4. Default return "wing_sessions" diff --git a/tests/test_hooks_cli.py b/tests/test_hooks_cli.py index 0918255..e9bd7d7 100644 --- a/tests/test_hooks_cli.py +++ b/tests/test_hooks_cli.py @@ -328,21 +328,171 @@ def test_wing_from_transcript_path_lowercases(): def test_wing_from_transcript_path_non_projects_layout(): - # Linux users with code under ~/dev/, ~/src/, ~/code/ — no -Projects- segment. - # Project name is the final dash-separated token of the encoded folder. + # Linux user with code under ~/dev/. The encoded form ``dev-MemPalace-mempalace`` + # is ambiguous between ``~/dev/MemPalace/mempalace/`` (project = mempalace) and + # ``~/dev/MemPalace-mempalace/`` (hyphenated single-name project). With no JSONL + # cwd to disambiguate, we preserve all post-``dev-`` segments rather than silently + # truncating to the last token (which would drop ``MemPalace`` here and collide + # with any other ``-mempalace`` leaf elsewhere on the system). path = "/home/igor/.claude/projects/-home-igor-dev-MemPalace-mempalace/session.jsonl" - assert _wing_from_transcript_path(path) == "wing_mempalace" + assert _wing_from_transcript_path(path) == "wing_mempalace_mempalace" def test_wing_from_transcript_path_macos_users_layout(): - # macOS ~/ layout without a Projects/ segment. + # macOS ~/ layout without a Projects/ segment — single-token project name + # so the heuristic produces the same result as the leaf-only approach. path = "/Users/alice/.claude/projects/-Users-alice-code-MyApp/session.jsonl" assert _wing_from_transcript_path(path) == "wing_myapp" def test_wing_from_transcript_path_nested_deep(): + # Deep tree: ``-home-bob-work-clients-acme-frontend``. Without JSONL cwd we + # can't tell whether ``frontend`` is the project, ``acme-frontend`` is a + # hyphenated project, or the project lives several levels in. Strip the + # user-home and one common parent (``work-``), then keep the remaining + # path as the wing — collision-safe even if multiple clients have a + # ``frontend/`` subdir. path = "/home/bob/.claude/projects/-home-bob-work-clients-acme-frontend/session.jsonl" - assert _wing_from_transcript_path(path) == "wing_frontend" + assert _wing_from_transcript_path(path) == "wing_clients_acme_frontend" + + +# --- _wing_from_transcript_path: hyphenated project names (issue #1410) --- + + +def test_wing_from_transcript_path_hyphenated_claude_code(): + """Regression: ``claude-code`` was truncated to ``wing_code`` (#1410).""" + path = "/Users/me/.claude/projects/-Users-me-claude-code/abc.jsonl" + assert _wing_from_transcript_path(path) == "wing_claude_code" + + +def test_wing_from_transcript_path_hyphenated_react_native(): + """Regression: ``react-native`` was truncated to ``wing_native`` (#1410).""" + path = "/Users/me/.claude/projects/-Users-me-react-native/abc.jsonl" + assert _wing_from_transcript_path(path) == "wing_react_native" + + +def test_wing_from_transcript_path_no_collision_between_hyphenated_siblings(): + """Regression: ``customer-portal`` and ``admin-portal`` both truncated to + ``wing_portal`` under the old heuristic, merging diary entries from two + independent projects into one wing (#1410).""" + customer = _wing_from_transcript_path( + "/Users/me/.claude/projects/-Users-me-customer-portal/abc.jsonl" + ) + admin = _wing_from_transcript_path( + "/Users/me/.claude/projects/-Users-me-admin-portal/abc.jsonl" + ) + assert customer == "wing_customer_portal" + assert admin == "wing_admin_portal" + assert customer != admin + + +def test_wing_from_transcript_path_strips_parent_dir_with_hyphenated_project(): + """Reporter's example: ``-home-alice-projects-react-native`` should keep + the full project name after stripping the ``projects-`` parent (#1410).""" + path = "/home/alice/.claude/projects/-home-alice-projects-react-native/abc.jsonl" + assert _wing_from_transcript_path(path) == "wing_react_native" + + +# --- _wing_from_transcript_path: cwd-from-JSONL primary path --- + + +def test_wing_from_transcript_path_uses_cwd_from_jsonl(tmp_path): + """When the JSONL records ``cwd``, the leaf segment of cwd is the wing — + even if the encoded folder name would have produced a different (and + noisier) wing.""" + # Encoded folder says ``-home-igor-dev-MemPalace-mempalace`` (would yield + # ``wing_mempalace_mempalace`` via fallback), but cwd is the truth. + project_dir = tmp_path / "-home-igor-dev-MemPalace-mempalace" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + transcript.write_text( + '{"type":"queue-operation","operation":"enqueue","timestamp":"2026-05-09T00:00:00Z"}\n' + '{"type":"user","cwd":"/home/igor/dev/MemPalace/mempalace","content":"hi"}\n', + encoding="utf-8", + ) + assert _wing_from_transcript_path(str(transcript)) == "wing_mempalace" + + +def test_wing_from_transcript_path_cwd_with_hyphenated_project(tmp_path): + """cwd primary path correctly handles hyphenated project names without + truncation.""" + project_dir = tmp_path / "-Users-me-claude-code" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + transcript.write_text( + '{"type":"user","cwd":"/Users/me/git/claude-code","content":"hi"}\n', + encoding="utf-8", + ) + assert _wing_from_transcript_path(str(transcript)) == "wing_claude_code" + + +def test_wing_from_transcript_path_cwd_skips_lines_without_cwd(tmp_path): + """Lines that lack ``cwd`` (queue-operation, etc.) are skipped; the first + line that records cwd wins.""" + project_dir = tmp_path / "-Users-me-foo" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + lines = [ + '{"type":"queue-operation","operation":"enqueue"}', + '{"type":"queue-operation","operation":"dequeue"}', + '{"type":"queue-operation","operation":"complete"}', + '{"type":"tool_use","cwd":"/Users/me/work/real-project","content":"ok"}', + '{"type":"user","cwd":"/Users/me/somewhere-else","content":"later"}', + ] + transcript.write_text("\n".join(lines) + "\n", encoding="utf-8") + # First cwd record wins (line 4, real-project). + assert _wing_from_transcript_path(str(transcript)) == "wing_real_project" + + +def test_wing_from_transcript_path_cwd_falls_back_when_no_cwd_in_jsonl(tmp_path): + """If no JSONL line has cwd, fall through to the encoded-folder heuristic.""" + project_dir = tmp_path / "-Users-me-no-cwd-project" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + transcript.write_text( + '{"type":"queue-operation","operation":"enqueue"}\n' + '{"type":"queue-operation","operation":"complete"}\n', + encoding="utf-8", + ) + # tmp_path leaks into the path before .claude/projects, so the regex + # won't match and we hit the wing_sessions default. The point of this + # test: the cwd reader doesn't crash and returns None cleanly. + result = _wing_from_transcript_path(str(transcript)) + assert result == "wing_sessions" + + +def test_wing_from_transcript_path_cwd_handles_malformed_jsonl(tmp_path): + """Malformed JSON lines must not crash the wing extraction.""" + project_dir = tmp_path / "-Users-me-broken-project" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + transcript.write_text( + "this is not json at all\n" + '{"type":"broken",\n' # truncated mid-record + '{"type":"valid","cwd":"/Users/me/git/clean-name","content":"ok"}\n', + encoding="utf-8", + ) + assert _wing_from_transcript_path(str(transcript)) == "wing_clean_name" + + +def test_wing_from_transcript_path_cwd_handles_missing_file(): + """Nonexistent transcript path falls back cleanly to the encoded heuristic.""" + path = "/Users/me/.claude/projects/-Users-me-claude-code/does-not-exist.jsonl" + assert _wing_from_transcript_path(path) == "wing_claude_code" + + +def test_wing_from_transcript_path_cwd_handles_non_string_cwd(tmp_path): + """A cwd field that isn't a string (e.g. null, number) must be skipped.""" + project_dir = tmp_path / "-Users-me-fallback-name" + project_dir.mkdir() + transcript = project_dir / "session.jsonl" + transcript.write_text( + '{"type":"x","cwd":null}\n' + '{"type":"x","cwd":42}\n' + '{"type":"x","cwd":"/Users/me/git/proper-name"}\n', + encoding="utf-8", + ) + assert _wing_from_transcript_path(str(transcript)) == "wing_proper_name" # --- _log ---