fix: update all _-prefix function names in the project

Author: bradjin8

api/workspaces.py

@@ -22,21 +22,13 @@
 )
 from utils.workspace_descriptor import read_json_file
 from services.workspace_resolver import (
-    determine_project_for_conversation,
-    infer_invalid_workspace_aliases,
     infer_workspace_name_from_context,
     lookup_workspace_display_name,
 )
 from services.cli_tabs import get_cli_workspace_tabs
 from services.workspace_listing import list_workspace_projects
 from services.workspace_tabs import assemble_workspace_tabs
 
-# Re-exported for back-compat with tests that import from api.workspaces directly.
-_determine_project_for_conversation = determine_project_for_conversation  # noqa: F401
-_infer_invalid_workspace_aliases = infer_invalid_workspace_aliases  # noqa: F401
-_get_workspace_display_name = lookup_workspace_display_name  # noqa: F401
-_infer_workspace_name_from_context = infer_workspace_name_from_context  # noqa: F401
-
 # Re-exported for tests/test_models_wired_at_read_sites.py — the typed-model
 # spy harness patches `workspaces_mod.Bubble` / `.Composer` / `.Workspace` to
 # verify that production read paths actually call from_dict. The classes

scripts/export.py

@@ -55,26 +55,26 @@
 )
 from models import ExportEntry, SchemaError  # noqa: E402
 from services.workspace_db import (  # noqa: E402
-    _build_composer_id_to_workspace_id,
-    _collect_invalid_workspace_ids,
-    _collect_workspace_entries,
+    build_composer_id_to_workspace_id,
+    collect_invalid_workspace_ids,
+    collect_workspace_entries,
     load_bubble_map,
     load_code_block_diff_map,
     load_project_layouts_map,
-    _open_global_db,
+    open_global_db,
 )
 from services.workspace_resolver import (  # noqa: E402
-    _determine_project_for_conversation,
-    _get_workspace_display_name,
-    _infer_invalid_workspace_aliases,
-    _create_project_name_to_workspace_id_map,
-    _create_workspace_path_to_id_map,
+    create_project_name_to_workspace_id_map,
+    create_workspace_path_to_id_map,
+    determine_project_for_conversation,
+    infer_invalid_workspace_aliases,
+    lookup_workspace_display_name,
 )
 
 _logger = logging.getLogger(__name__)
 
 
-def _configure_cli_logging() -> None:
+def configure_cli_logging() -> None:
     """Route log records to stderr so stdout stays for export progress lines."""
     root = logging.getLogger()
     if root.handlers:
@@ -86,15 +86,15 @@ def _configure_cli_logging() -> None:
     )
 
 
-def _json_dump_safe(value) -> str:
+def json_dump_safe(value) -> str:
     """Best-effort JSON serialization for exclusion matching."""
     try:
         return json.dumps(value, ensure_ascii=False, sort_keys=True)
     except Exception:
         return str(value) if value is not None else ""
 
 
-def _load_manifest_entries(manifest_path: str) -> dict:
+def load_manifest_entries(manifest_path: str) -> dict:
     """Load manifest entries keyed by log_id from a JSONL file."""
     existing: dict = {}
     if not os.path.isfile(manifest_path):
@@ -117,7 +117,7 @@ def _load_manifest_entries(manifest_path: str) -> dict:
     return existing
 
 
-def _write_manifest_entries(manifest_path: str, entries_by_id: dict):
+def write_manifest_entries(manifest_path: str, entries_by_id: dict):
     """Write manifest entries to JSONL."""
     os.makedirs(os.path.dirname(manifest_path), exist_ok=True)
     with open(manifest_path, "w", encoding="utf-8") as f:
@@ -177,7 +177,7 @@ def parse_args():
 
 
 def main():
-    _configure_cli_logging()
+    configure_cli_logging()
     opts = parse_args()
     since = opts["since"]
     out_dir = os.path.abspath(opts["out_dir"])
@@ -201,11 +201,11 @@ def main():
             pass
 
     # ── Workspace scanning via service layer ──────────────────────────────────
-    workspace_entries = _collect_workspace_entries(workspace_path)
-    invalid_workspace_ids = _collect_invalid_workspace_ids(workspace_entries)
-    project_name_map = _create_project_name_to_workspace_id_map(workspace_entries)
-    workspace_path_map = _create_workspace_path_to_id_map(workspace_entries)
-    composer_id_to_ws = _build_composer_id_to_workspace_id(workspace_path, workspace_entries)
+    workspace_entries = collect_workspace_entries(workspace_path)
+    invalid_workspace_ids = collect_invalid_workspace_ids(workspace_entries)
+    project_name_map = create_project_name_to_workspace_id_map(workspace_entries)
+    workspace_path_map = create_workspace_path_to_id_map(workspace_entries)
+    composer_id_to_ws = build_composer_id_to_workspace_id(workspace_path, workspace_entries)
 
     # Build display-name and slug maps from workspace entries.
     # Entries whose workspace.json cannot be resolved are omitted so the
@@ -214,7 +214,7 @@ def main():
     workspace_id_to_display_name: dict[str, str] = {}
     workspace_id_to_slug: dict[str, str] = {}
     for e in workspace_entries:
-        display = _get_workspace_display_name(workspace_path, e["name"])
+        display = lookup_workspace_display_name(workspace_path, e["name"])
         if display != e["name"]:  # successfully resolved a human-readable name
             workspace_id_to_display_name[e["name"]] = display
             workspace_id_to_slug[e["name"]] = slug(display)
@@ -226,7 +226,7 @@ def main():
     ide_composer_rows: list = []
     invalid_workspace_aliases: dict = {}
 
-    with _open_global_db(workspace_path) as (global_db, global_db_path):
+    with open_global_db(workspace_path) as (global_db, global_db_path):
         if global_db is None:
             _logger.info(
                 "Cursor IDE global storage not found at %s — skipping IDE chats.",
@@ -245,7 +245,7 @@ def main():
             except sqlite3.Error:
                 pass
 
-            invalid_workspace_aliases = _infer_invalid_workspace_aliases(
+            invalid_workspace_aliases = infer_invalid_workspace_aliases(
                 composer_rows=ide_composer_rows,
                 project_layouts_map=project_layouts_map,
                 project_name_map=project_name_map,
@@ -278,7 +278,7 @@ def main():
             continue
 
         # Workspace assignment via service layer
-        pid = _determine_project_for_conversation(
+        pid = determine_project_for_conversation(
             cd, composer_id, project_layouts_map,
             project_name_map, workspace_path_map,
             workspace_entries, bubble_map, composer_id_to_ws, invalid_workspace_ids,
@@ -307,9 +307,9 @@ def main():
             text = extract_text_from_bubble(b)
             if text:
                 bubble_texts.append(text)
-            bubble_meta_parts.append(_json_dump_safe(b))
+            bubble_meta_parts.append(json_dump_safe(b))
 
-        code_diff_parts = [_json_dump_safe(d) for d in code_block_diff_map.get(composer_id, [])]
+        code_diff_parts = [json_dump_safe(d) for d in code_block_diff_map.get(composer_id, [])]
         searchable = build_searchable_text(
             project_name=ws_display_name,
             chat_title=title,
@@ -320,7 +320,7 @@ def main():
                     bubble_texts
                     + bubble_meta_parts
                     + code_diff_parts
-                    + [_json_dump_safe(model_config), _json_dump_safe(cd)]
+                    + [json_dump_safe(model_config), json_dump_safe(cd)]
                 )
                 if p
             ),
@@ -484,7 +484,7 @@ def main():
                 f.write(entry["content"])
 
         manifest_path = os.path.join(out_dir, "manifest.jsonl")
-        existing = _load_manifest_entries(manifest_path)
+        existing = load_manifest_entries(manifest_path)
         for entry in exported:
             existing[entry["id"]] = {
                 "log_id": entry["id"],
@@ -494,10 +494,10 @@ def main():
                 "updated_at": datetime.fromtimestamp(entry["updatedAt"] / 1000).isoformat() if entry["updatedAt"] else datetime.now().isoformat(),
             }
         if existing:
-            _write_manifest_entries(manifest_path, existing)
+            write_manifest_entries(manifest_path, existing)
 
         global_manifest_path = os.path.join(state_dir, "manifest.jsonl")
-        global_existing = _load_manifest_entries(global_manifest_path)
+        global_existing = load_manifest_entries(global_manifest_path)
         for entry in exported:
             global_existing[entry["id"]] = {
                 "log_id": entry["id"],
@@ -507,7 +507,7 @@ def main():
                 "updated_at": datetime.fromtimestamp(entry["updatedAt"] / 1000).isoformat() if entry["updatedAt"] else datetime.now().isoformat(),
             }
         if global_existing:
-            _write_manifest_entries(global_manifest_path, global_existing)
+            write_manifest_entries(global_manifest_path, global_existing)
         print(f"Exported {count} chat(s) to {out_dir}")
 
     state = {

services/cli_tabs.py

@@ -146,7 +146,3 @@ def get_cli_workspace_tabs(workspace_id: str):
             exc_info=True,
         )
         return jsonify({"error": "Failed to get CLI workspace tabs"}), 500
-
-
-# Backward-compatible alias for tests and legacy imports.
-_get_cli_workspace_tabs = get_cli_workspace_tabs

services/workspace_db.py

@@ -240,10 +240,3 @@ def open_global_db(workspace_path: str):
         yield conn, global_db_path
     finally:
         conn.close()
-
-
-# Backward-compatible aliases for tests and legacy imports.
-_collect_workspace_entries = collect_workspace_entries
-_collect_invalid_workspace_ids = collect_invalid_workspace_ids
-_build_composer_id_to_workspace_id = build_composer_id_to_workspace_id
-_open_global_db = open_global_db

services/workspace_resolver.py

@@ -404,13 +404,3 @@ def infer_invalid_workspace_aliases(
             continue
         aliases[invalid_id] = max(counts.items(), key=lambda kv: kv[1])[0]
     return aliases
-
-
-# Backward-compatible aliases for tests and legacy imports.
-_get_workspace_display_name = lookup_workspace_display_name
-_infer_workspace_name_from_context = infer_workspace_name_from_context
-_get_project_from_file_path = get_project_from_file_path
-_create_project_name_to_workspace_id_map = create_project_name_to_workspace_id_map
-_create_workspace_path_to_id_map = create_workspace_path_to_id_map
-_determine_project_for_conversation = determine_project_for_conversation
-_infer_invalid_workspace_aliases = infer_invalid_workspace_aliases

services/workspace_tabs.py

@@ -18,7 +18,7 @@
 )
 from utils.exclusion_rules import build_searchable_text, is_excluded_by_rules
 from utils.text_extract import extract_text_from_bubble
-from utils.tool_parser import parse_tool_call as _parse_tool_call
+from utils.tool_parser import parse_tool_call
 from utils.workspace_descriptor import read_json_file
 from models import Bubble, Composer, ParseWarningCollector, SchemaError
 from services.workspace_db import (
@@ -342,7 +342,7 @@ def _safe_fetchall(query: str, params: tuple = ()) -> list:
                     tool_calls = None
                     tfd = raw.get("toolFormerData")
                     if isinstance(tfd, dict):
-                        tool_call = _parse_tool_call(tfd)
+                        tool_call = parse_tool_call(tfd)
                         if isinstance(tool_call, dict):
                             tool_calls = [tool_call]
 

tests/test_api_endpoints.py

@@ -2,7 +2,7 @@
 
 from app import create_app
 from tests._fixture_ids import HAPPY_BUBBLE_ID, HAPPY_COMPOSER_ID, HAPPY_WORKSPACE_ID
-from utils.exclusion_rules import _tokenize_rule
+from utils.exclusion_rules import tokenize_rule
 
 
 # ---------------------------------------------------------------------------
@@ -155,7 +155,7 @@ def _client_with_rules(rule_lines):
     overrides the config with parsed rules — exercising the same code path
     a real `exclusion-rules.txt` file would.
     """
-    parsed = [_tokenize_rule(line) for line in rule_lines]
+    parsed = [tokenize_rule(line) for line in rule_lines]
     app = create_app()
     app.config["TESTING"] = True
     app.config["EXCLUSION_RULES"] = [r for r in parsed if r]

tests/test_cli_chat_reader.py

@@ -19,10 +19,10 @@
     sys.path.insert(0, str(_root))
 
 from utils.cli_chat_reader import (
-    _content_to_text,
+    content_to_text,
     extract_blob_refs,
-    _extract_tool_calls,
-    _strip_user_info,
+    extract_tool_calls,
+    strip_user_info,
     aggregate_session_stats,
     extract_workspace_path,
     iter_sessions,
@@ -106,53 +106,53 @@ def test_partial_tag_at_end_ignored(self):
 
 
 # ---------------------------------------------------------------------------
-# _content_to_text
+# content_to_text
 # ---------------------------------------------------------------------------
 
 class TestContentToText(unittest.TestCase):
     def test_string_passthrough(self):
-        self.assertEqual(_content_to_text("hello"), "hello")
+        self.assertEqual(content_to_text("hello"), "hello")
 
     def test_list_with_text_parts(self):
         content = [{"type": "text", "text": "foo"}, {"type": "text", "text": "bar"}]
-        result = _content_to_text(content)
+        result = content_to_text(content)
         self.assertIn("foo", result)
         self.assertIn("bar", result)
 
     def test_list_with_tool_result(self):
         content = [{"type": "tool-result", "result": "output here"}]
-        self.assertIn("output here", _content_to_text(content))
+        self.assertIn("output here", content_to_text(content))
 
     def test_empty_list(self):
-        self.assertEqual(_content_to_text([]), "")
+        self.assertEqual(content_to_text([]), "")
 
     def test_unknown_type_ignored(self):
         content = [{"type": "image", "url": "http://example.com/img.png"}]
-        self.assertEqual(_content_to_text(content), "")
+        self.assertEqual(content_to_text(content), "")
 
     def test_non_string_non_list(self):
-        self.assertEqual(_content_to_text(None), "")
-        self.assertEqual(_content_to_text(42), "")
+        self.assertEqual(content_to_text(None), "")
+        self.assertEqual(content_to_text(42), "")
 
 
 # ---------------------------------------------------------------------------
-# _extract_tool_calls
+# extract_tool_calls
 # ---------------------------------------------------------------------------
 
 class TestExtractToolCalls(unittest.TestCase):
     def test_non_list_returns_empty(self):
-        self.assertEqual(_extract_tool_calls("text"), [])
-        self.assertEqual(_extract_tool_calls(None), [])
+        self.assertEqual(extract_tool_calls("text"), [])
+        self.assertEqual(extract_tool_calls(None), [])
 
     def test_list_without_tool_call_type(self):
         content = [{"type": "text", "text": "hello"}]
-        self.assertEqual(_extract_tool_calls(content), [])
+        self.assertEqual(extract_tool_calls(content), [])
 
     def test_single_tool_call(self):
         content = [
             {"type": "tool-call", "toolName": "Shell", "args": {"command": "ls"}, "toolCallId": "tc-1"}
         ]
-        calls = _extract_tool_calls(content)
+        calls = extract_tool_calls(content)
         self.assertEqual(len(calls), 1)
         self.assertEqual(calls[0]["name"], "Shell")
         self.assertEqual(calls[0]["args"], {"command": "ls"})
@@ -163,7 +163,7 @@ def test_mixed_content(self):
             {"type": "text", "text": "I will run a command."},
             {"type": "tool-call", "toolName": "Grep", "args": {"pattern": "foo"}, "toolCallId": "tc-2"},
         ]
-        calls = _extract_tool_calls(content)
+        calls = extract_tool_calls(content)
         self.assertEqual(len(calls), 1)
         self.assertEqual(calls[0]["name"], "Grep")
 
@@ -203,22 +203,22 @@ def test_returns_first_match(self):
 
 
 # ---------------------------------------------------------------------------
-# _strip_user_info
+# strip_user_info
 # ---------------------------------------------------------------------------
 
 class TestStripUserInfo(unittest.TestCase):
     def test_extracts_user_query_tag(self):
         text = "<user_info>some preamble</user_info>\n<user_query>my actual question</user_query>"
-        self.assertEqual(_strip_user_info(text), "my actual question")
+        self.assertEqual(strip_user_info(text), "my actual question")
 
     def test_strips_user_info_block_when_no_query_tag(self):
         text = "<user_info>preamble stuff</user_info>\nActual message here."
-        result = _strip_user_info(text)
+        result = strip_user_info(text)
         self.assertNotIn("<user_info>", result)
         self.assertIn("Actual message here.", result)
 
     def test_passthrough_when_no_user_info(self):
-        self.assertEqual(_strip_user_info("plain text"), "plain text")
+        self.assertEqual(strip_user_info("plain text"), "plain text")
 
 
 # ---------------------------------------------------------------------------