Address Timon's feedback

Author: clean6378-max-it

models/error_codes.py

@@ -14,6 +14,8 @@ class ErrorCode(StrEnum):
     SEARCH_INDEX_UNAVAILABLE = "SEARCH_INDEX_UNAVAILABLE"
     INVALID_PATH = "INVALID_PATH"
     SESSION_NOT_FOUND = "SESSION_NOT_FOUND"
+    SESSION_AMBIGUOUS_PREFIX = "SESSION_AMBIGUOUS_PREFIX"
+    PROJECTS_DIR_NOT_FOUND = "PROJECTS_DIR_NOT_FOUND"
     INVALID_REQUEST_BODY = "INVALID_REQUEST_BODY"
     INVALID_SINCE_MODE = "INVALID_SINCE_MODE"
     PARSE_ERROR = "PARSE_ERROR"

scripts/export.py

@@ -24,7 +24,7 @@
 import sys
 import zipfile
 from datetime import datetime
-from typing import cast
+from typing import NoReturn, cast
 
 # Allow running from repo root or scripts/ directory
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -182,11 +182,7 @@ def cmd_list(args):
     base_dir = getattr(args, "base_dir", None) or get_claude_projects_dir()
     project_filter = getattr(args, "project", None)
 
-    if not os.path.isdir(base_dir):
-        _die(
-            ErrorCode.INTERNAL_ERROR,
-            detail=f"Claude Code projects directory not found: {base_dir}",
-        )
+    _require_projects_dir(base_dir)
 
     projects = list_projects(base_dir)
     if project_filter:
@@ -249,11 +245,7 @@ def cmd_stats(args):
     session_id = getattr(args, "session", None)
     fmt = getattr(args, "format", "text") or "text"
 
-    if not os.path.isdir(base_dir):
-        _die(
-            ErrorCode.INTERNAL_ERROR,
-            detail=f"Claude Code projects directory not found: {base_dir}",
-        )
+    _require_projects_dir(base_dir)
 
     if session_id:
         _session_stats(session_id, base_dir, fmt)
@@ -459,11 +451,7 @@ def cmd_export(args):
     session_filter = getattr(args, "session", None)
     exclusion_rules_path = getattr(args, "exclude_rules", None)
 
-    if not os.path.isdir(base_dir):
-        _die(
-            ErrorCode.INTERNAL_ERROR,
-            detail=f"Claude Code projects directory not found: {base_dir}",
-        )
+    _require_projects_dir(base_dir)
 
     rules = load_rules(resolve_exclusion_rules_path(exclusion_rules_path))
 
@@ -725,7 +713,7 @@ def _find_session(session_id: str, base_dir: str) -> str | None:
         return matches[0]["path"]
     if len(matches) > 1:
         _die(
-            ErrorCode.SESSION_NOT_FOUND,
+            ErrorCode.SESSION_AMBIGUOUS_PREFIX,
             detail=(
                 f"Ambiguous prefix '{session_id}' matches {len(matches)} sessions:\n"
                 + "\n".join(f"  {m['id']}" for m in matches)
@@ -774,14 +762,22 @@ def _save_state(sessions: dict, count: int, out_dir: str):
         atomic_write_export_state(disk, STATE_FILE)
 
 
+def _require_projects_dir(base_dir: str) -> None:
+    if not os.path.isdir(base_dir):
+        _die(
+            ErrorCode.PROJECTS_DIR_NOT_FOUND,
+            detail=f"Claude Code projects directory not found: {base_dir}",
+        )
+
+
 def _cli_die_message(code: ErrorCode) -> str:
     """Stable CLI stderr label (not export-scoped)."""
     if code == ErrorCode.INTERNAL_ERROR:
         return "Command failed"
     return failure_message_for_code(code)
 
 
-def _die(code: ErrorCode, *, detail: str | None = None) -> None:
+def _die(code: ErrorCode, *, detail: str | None = None) -> NoReturn:
     print(f"Error: {code.value} — {_cli_die_message(code)}", file=sys.stderr)
     if detail:
         print(detail, file=sys.stderr)

tests/test_error_codes.py

@@ -11,7 +11,7 @@
 from api.error_codes import ErrorCode
 from api.search import _IndexSearchOutcome
 from tests.conftest import assert_error_response
-from tests.test_cli_e2e import _run_cli
+from tests.test_cli_e2e import FIXTURES, _run_cli
 
 
 @pytest.mark.parametrize(
@@ -100,18 +100,19 @@ def _raise_live_scan_failure(*_args, **_kwargs):
 @pytest.mark.parametrize(
     "argv,code",
     [
-        (["export", "--base-dir"], "INTERNAL_ERROR"),
-        (["stats", "--base-dir"], "INTERNAL_ERROR"),
-        (["list", "--base-dir"], "INTERNAL_ERROR"),
+        (["export", "--base-dir"], "PROJECTS_DIR_NOT_FOUND"),
+        (["stats", "--base-dir"], "PROJECTS_DIR_NOT_FOUND"),
+        (["list", "--base-dir"], "PROJECTS_DIR_NOT_FOUND"),
     ],
 )
 def test_cli_missing_projects_dir_surfaces_error_code(tmp_path, argv: list[str], code: str) -> None:
     missing = tmp_path / "missing-claude-dir"
     proc = _run_cli([*argv, str(missing)])
     assert proc.returncode == 1
     assert code in proc.stderr
+    assert "Claude projects directory not found" in proc.stderr
     assert "Failed to export session" not in proc.stderr
-    assert "Command failed" in proc.stderr
+    assert "Command failed" not in proc.stderr
     assert "Traceback" not in proc.stderr
 
 
@@ -134,3 +135,18 @@ def test_cli_export_session_not_found_surfaces_code(tmp_path, capsys) -> None:
     assert exc_info.value.code == 1
     captured = capsys.readouterr()
     assert "SESSION_NOT_FOUND" in captured.err
+
+
+def test_cli_ambiguous_session_prefix_surfaces_code(tmp_path) -> None:
+    base = tmp_path / "projects"
+    project = base / "test-project"
+    project.mkdir(parents=True)
+    content = (FIXTURES / "session_minimal.jsonl").read_text(encoding="utf-8")
+    content = content.replace("demo-project", "test-project")
+    (project / "session_aaa111.jsonl").write_text(content, encoding="utf-8")
+    (project / "session_aaa222.jsonl").write_text(content, encoding="utf-8")
+
+    proc = _run_cli(["stats", "--base-dir", str(base), "--session", "session_aaa"])
+    assert proc.returncode == 1
+    assert "SESSION_AMBIGUOUS_PREFIX" in proc.stderr
+    assert "SESSION_NOT_FOUND" not in proc.stderr.split("SESSION_AMBIGUOUS_PREFIX")[0]

tests/test_tool_dispatch_sync.py

@@ -77,41 +77,39 @@ def _parse_frontend_tool_result_renderers(path: Path) -> frozenset[str]:
     return _parse_frontend_registry_keys(path, "export const TOOL_RESULT_RENDERERS = {")
 
 
+def _parse_top_level_function_body(text: str, func_name: str) -> str:
+    """Slice a module-level ``def`` through the next top-level ``def`` (if any)."""
+    match = re.search(
+        rf"^def {re.escape(func_name)}\(.*?(?=^\ndef )",
+        text,
+        re.DOTALL | re.MULTILINE,
+    )
+    if not match:
+        msg = f"Could not find {func_name!r} in module"
+        raise ValueError(msg)
+    return match.group(0)
+
+
 def _parse_dispatch_builder_result_types(path: Path) -> frozenset[str]:
     """Extract ``result_type`` literals from tool-result dispatch builders."""
     text = path.read_text(encoding="utf-8")
     types = set(re.findall(r'result\["result_type"\]\s*=\s*"([^"]+)"', text))
+    # "unknown" is the dispatch fallback when no builder sets result_type; no renderer.
     types.discard("unknown")
     return frozenset(types)
 
 
 def _parse_md_exporter_tool_result_handlers(path: Path) -> frozenset[str]:
     """Extract ``result_type`` values handled by ``_render_tool_result`` branches."""
     text = path.read_text(encoding="utf-8")
-    match = re.search(
-        r"def _render_tool_result\(.*?(?=\ndef _render_system)",
-        text,
-        re.DOTALL,
-    )
-    if not match:
-        msg = f"Could not find _render_tool_result in {path}"
-        raise ValueError(msg)
-    body = match.group(0)
+    body = _parse_top_level_function_body(text, "_render_tool_result")
     return frozenset(re.findall(r'(?:if|elif) rt == "([^"]+)"', body))
 
 
 def _parse_md_exporter_tool_use_handlers(path: Path) -> frozenset[str]:
     """Extract tool names handled by ``_render_tool_use`` if/elif branches."""
     text = path.read_text(encoding="utf-8")
-    match = re.search(
-        r"def _render_tool_use\(.*?(?=\ndef _render_tool_result)",
-        text,
-        re.DOTALL,
-    )
-    if not match:
-        msg = f"Could not find _render_tool_use in {path}"
-        raise ValueError(msg)
-    body = match.group(0)
+    body = _parse_top_level_function_body(text, "_render_tool_use")
     names = set(re.findall(r'(?:if|elif) name == "([^"]+)"', body))
     for tuple_match in re.finditer(r"elif name in \(([^)]+)\)", body):
         names.update(re.findall(r'"([^"]+)"', tuple_match.group(1)))

utils/export_engine.py

@@ -90,6 +90,10 @@ def failure_message_for_code(code: ErrorCode) -> str:
         return "Failed to export session"
     if code == ErrorCode.SESSION_NOT_FOUND:
         return "Session not found"
+    if code == ErrorCode.SESSION_AMBIGUOUS_PREFIX:
+        return "Session prefix matches more than one session"
+    if code == ErrorCode.PROJECTS_DIR_NOT_FOUND:
+        return "Claude projects directory not found"
     if code == ErrorCode.EXPORT_ALL_FAILED:
         return "All sessions failed to export"
     return "Export failed"