fix: resolve Windows project paths in --project flag

Accept real Windows paths (D:\jarvis\space), forward-slash paths
(D:/jarvis/space), and table display names (D//jarvis/space) in the
--project flag for both `advise` and `analyze` commands.

Adds project_path_to_encoded_name() to parser.py and updates
_resolve_projects() with a two-strategy lookup: direct directory
first, then encoded name under ~/.claude/projects/. Also adds
exists=False to advise_cmd's --project option. Bumps version to 0.1.2.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jakeefr

prism/__init__.py

@@ -1,3 +1,3 @@
 """PRISM — session intelligence for Claude Code."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"

prism/cli.py

@@ -18,7 +18,13 @@
 
 from prism import __version__
 from prism.analyzer import analyze_project, score_to_grade
-from prism.parser import CLAUDE_PROJECTS_DIR, ProjectInfo, discover_projects, parse_session_file
+from prism.parser import (
+    CLAUDE_PROJECTS_DIR,
+    ProjectInfo,
+    discover_projects,
+    parse_session_file,
+    project_path_to_encoded_name,
+)
 
 # Force UTF-8 output on Windows so Unicode symbols render correctly
 if hasattr(sys.stdout, "reconfigure"):
@@ -227,6 +233,7 @@ def advise_cmd(
         "--project",
         "-p",
         help="Path to a specific project directory.",
+        exists=False,
     ),
     apply: bool = typer.Option(
         False,
@@ -393,22 +400,58 @@ def _resolve_projects(
     project_path: Path | None,
     base_dir: Path | None,
 ) -> list[ProjectInfo]:
-    """Return a list of ProjectInfo objects based on CLI options."""
+    """Return a list of ProjectInfo objects based on CLI options.
+
+    The ``--project`` flag accepts any of:
+
+    * The actual path to a Claude Code project directory (inside
+      ``~/.claude/projects/``), e.g. ``~/.claude/projects/D--jarvis-space``.
+    * The real absolute path of the user's workspace on any OS, e.g.
+      ``D:\\jarvis\\space`` or ``/home/user/proj``.  The path is encoded
+      to the Claude Code convention and looked up under *effective_base*.
+    * The display name shown in the projects table, e.g. ``D//jarvis/space``
+      or ``/home/user/proj``.  Forward-slash normalisation by ``pathlib``
+      means this is equivalent to passing the real path on most systems.
+    """
     effective_base = base_dir or CLAUDE_PROJECTS_DIR
 
     if project_path is not None:
-        # User pointed at a specific project directory
+        # Strategy 1: the argument is already a Claude Code project directory
+        # that contains JSONL session files — use it directly.
         if project_path.is_dir():
-            from prism.parser import ProjectInfo
-            sessions = sorted(project_path.glob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)
+            sessions = sorted(
+                project_path.glob("*.jsonl"),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True,
+            )
+            if sessions:
+                return [ProjectInfo(
+                    encoded_name=project_path.name,
+                    project_dir=project_path,
+                    session_files=sessions,
+                )]
+
+        # Strategy 2: interpret the argument as a real path or display name
+        # and look up the corresponding encoded directory inside effective_base.
+        encoded = project_path_to_encoded_name(str(project_path))
+        candidate = effective_base / encoded
+        if candidate.is_dir():
+            sessions = sorted(
+                candidate.glob("*.jsonl"),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True,
+            )
             return [ProjectInfo(
-                encoded_name=project_path.name,
-                project_dir=project_path,
+                encoded_name=encoded,
+                project_dir=candidate,
                 session_files=sessions,
             )]
-        else:
-            err_console.print(f"[red]Project path is not a directory: {project_path}[/red]")
-            return []
+
+        err_console.print(f"[red]Project not found: {project_path}[/red]")
+        err_console.print(
+            f"[dim]Tried encoded name '{encoded}' in {effective_base}[/dim]"
+        )
+        return []
 
     return discover_projects(effective_base)
 

prism/parser.py

@@ -259,6 +259,32 @@ def last_active(self) -> str | None:
         return newest.stat().st_mtime.__class__.__name__  # return mtime float str
 
 
+def project_path_to_encoded_name(path_str: str) -> str:
+    """Convert a path string to a Claude Code encoded project directory name.
+
+    Claude Code stores project sessions under ``~/.claude/projects/`` using
+    directory names that are the absolute project path with every path
+    separator and colon replaced by a hyphen.  This function performs that
+    same normalisation so callers can look up a project by its real path
+    *or* by the display name shown in the projects table.
+
+    Examples::
+
+        "D:\\\\jarvis\\\\space"  ->  "D--jarvis-space"   # native Windows path
+        "D:/jarvis/space"       ->  "D--jarvis-space"   # forward-slash Windows
+        "D//jarvis/space"       ->  "D--jarvis-space"   # display name from table
+        "/home/user/proj"       ->  "-home-user-proj"   # Unix path
+
+    Args:
+        path_str: A real absolute path (any OS) or a display name from the
+                  projects table.
+
+    Returns:
+        The encoded directory name used by Claude Code.
+    """
+    return path_str.replace("\\", "-").replace("/", "-").replace(":", "-")
+
+
 def discover_projects(base_dir: Path | None = None) -> list[ProjectInfo]:
     """Discover all Claude Code projects under base_dir (default: ~/.claude/projects).
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "prism-cc"
-version = "0.1.1"
+version = "0.1.2"
 description = "Session intelligence for Claude Code — find why your sessions fail and fix them"
 readme = "README.md"
 license = { text = "MIT" }

tests/test_parser.py

@@ -11,11 +11,13 @@
     AssistantRecord,
     ContentBlock,
     ParseResult,
+    ProjectInfo,
     SystemRecord,
     UserRecord,
     discover_projects,
     parse_record,
     parse_session_file,
+    project_path_to_encoded_name,
 )
 
 FIXTURES = Path(__file__).parent / "fixtures"
@@ -352,3 +354,42 @@ def test_non_jsonl_files_ignored(self, tmp_path):
         projects = discover_projects(tmp_path)
         assert len(projects[0].session_files) == 1
         assert projects[0].session_files[0].suffix == ".jsonl"
+
+
+# ---------------------------------------------------------------------------
+# project_path_to_encoded_name tests
+# ---------------------------------------------------------------------------
+
+class TestProjectPathToEncodedName:
+    """Verify encoding round-trips for Windows paths, Unix paths, and display names."""
+
+    def test_unix_absolute_path(self):
+        assert project_path_to_encoded_name("/home/user/myproject") == "-home-user-myproject"
+
+    def test_unix_nested_path(self):
+        assert project_path_to_encoded_name("/home/alice/work/proj") == "-home-alice-work-proj"
+
+    def test_windows_backslash_path(self):
+        # Native Windows path with backslash separators
+        assert project_path_to_encoded_name("D:\\jarvis\\space") == "D--jarvis-space"
+
+    def test_windows_forward_slash_path(self):
+        # Windows path written with forward slashes
+        assert project_path_to_encoded_name("D:/jarvis/space") == "D--jarvis-space"
+
+    def test_windows_display_name(self):
+        # Display name as shown in the projects table (D:\ → D-- after decode)
+        assert project_path_to_encoded_name("D//jarvis/space") == "D--jarvis-space"
+
+    def test_already_encoded_name_unchanged(self):
+        # An already-encoded name has no path chars — passes through as-is
+        assert project_path_to_encoded_name("D--jarvis-space") == "D--jarvis-space"
+
+    def test_display_name_roundtrip(self):
+        """display_name -> encode -> same encoded dir name."""
+        encoded = "D--jarvis-space"
+        info = ProjectInfo(encoded_name=encoded, project_dir=Path("."), session_files=[])
+        # display_name replaces "-" with "/" giving "D//jarvis/space"
+        display = info.display_name
+        # re-encoding the display should yield the original encoded name
+        assert project_path_to_encoded_name(display) == encoded