initial implementation of the issue requirements

Author: bradjin8

api/composers.py

@@ -78,7 +78,12 @@ def list_composers():
                         try:
                             local = WorkspaceLocalComposer.from_dict(c)
                         except SchemaError as e:
-                            print(f"Schema drift in {db_path}: {e}")
+                            _logger.warning(
+                                "Schema drift in %s: %s (%s)",
+                                db_path,
+                                e,
+                                type(e).__name__,
+                            )
                             continue
                         # Use the typed view downstream so the dataclass is
                         # load-bearing, not just a filter (Brad's review): the
@@ -91,9 +96,20 @@ def list_composers():
                         c["workspaceFolder"] = workspace_folder
                         composers.append((local, c))
             except SchemaError as e:
-                print(f"Schema drift in {db_path}: {e}")
+                _logger.warning(
+                    "Schema drift in %s: %s (%s)",
+                    db_path,
+                    e,
+                    type(e).__name__,
+                )
             except Exception as e:
-                print(f"Failed reading composers from {db_path}: {e}")
+                _logger.error(
+                    "Failed reading composers from %s: %s (%s)",
+                    db_path,
+                    e,
+                    type(e).__name__,
+                    exc_info=True,
+                )
 
         composers.sort(key=lambda pair: to_epoch_ms(pair[0].last_updated_at), reverse=True)
         return jsonify([c for _, c in composers])
@@ -152,7 +168,12 @@ def get_composer(composer_id):
                                 # Same drift list_composers() logs and skips at line ~78,
                                 # so a single-composer fetch can't silently return malformed
                                 # JSON the list endpoint hid.
-                                print(f"Schema drift in workspace-local composer {composer_id}: {e}")
+                                _logger.warning(
+                                    "Schema drift in workspace-local composer %s: %s (%s)",
+                                    composer_id,
+                                    e,
+                                    type(e).__name__,
+                                )
                                 continue
                             # Match list_composers() at line 89 and the global
                             # fallback below: `conversation` is normalised to []
@@ -163,7 +184,12 @@ def get_composer(composer_id):
                             payload["conversation"] = payload.get("conversation") or []
                             return jsonify(payload)
             except SchemaError as e:
-                print(f"Schema drift in {db_path}: {e}")
+                _logger.warning(
+                    "Schema drift in %s: %s (%s)",
+                    db_path,
+                    e,
+                    type(e).__name__,
+                )
             except (OSError, sqlite3.Error, json.JSONDecodeError, ValueError):
                 pass
 
@@ -186,7 +212,12 @@ def get_composer(composer_id):
                         # Don't return malformed JSON to the client — surface the drift
                         # as a 404 + log, matching the silent-skip behaviour of the
                         # list endpoints for the same row.
-                        print(f"Schema drift in composer {composer_id}: {e}")
+                        _logger.warning(
+                            "Schema drift in composer %s: %s (%s)",
+                            composer_id,
+                            e,
+                            type(e).__name__,
+                        )
                         return jsonify({"error": "Composer schema drift"}), 404
                     payload = dict(composer.raw)
                     payload["conversation"] = payload.get("conversation") or []

api/config_api.py

@@ -6,6 +6,7 @@
   src/app/api/get-username/route.ts        GET /api/get-username
 """
 
+import logging
 import os
 import subprocess
 import sys
@@ -16,6 +17,7 @@
 from utils.workspace_path import set_workspace_path_override
 
 bp = Blueprint("config_api", __name__)
+_logger = logging.getLogger(__name__)
 
 
 @bp.route("/api/detect-environment")
@@ -44,7 +46,12 @@ def detect_environment():
         })
 
     except Exception as e:
-        print(f"Failed to detect environment: {e}")
+        _logger.warning(
+            "Failed to detect environment: %s (%s)",
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"os": "unknown", "isWSL": False, "isRemote": False})
 
 
@@ -80,7 +87,12 @@ def validate_path():
         )
 
     except Exception as e:
-        print(f"Validation error: {e}")
+        _logger.error(
+            "Validation error: %s (%s)",
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"valid": False, "error": "Failed to validate path"}), 500
 
 
@@ -135,5 +147,10 @@ def get_username():
         return jsonify({"username": username})
 
     except Exception as e:
-        print(f"Failed to get username: {e}")
+        _logger.warning(
+            "Failed to get username: %s (%s)",
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"username": "YOUR_USERNAME"})

api/export_api.py

@@ -6,6 +6,7 @@
 
 import io
 import json
+import logging
 import os
 import sqlite3
 import zipfile
@@ -32,6 +33,7 @@
 )
 
 bp = Blueprint("export_api", __name__)
+_logger = logging.getLogger(__name__)
 
 
 def _get_state_dir() -> str:
@@ -181,7 +183,13 @@ def export_chats():
                     exported.append({"path": rel_path, "content": md, "updatedAt": updated_at_ms})
 
                 except Exception as e:
-                    print(f"Error processing composer {composer_id} for export: {e}")
+                    _logger.error(
+                        "Error processing composer %s for export: %s (%s)",
+                        composer_id,
+                        e,
+                        type(e).__name__,
+                        exc_info=True,
+                    )
 
         count = len(exported)
         if count == 0:
@@ -208,7 +216,10 @@ def export_chats():
         )
 
     except Exception as e:
-        print(f"Export error: {e}")
-        import traceback
-        traceback.print_exc()
+        _logger.error(
+            "Export failed: %s (%s)",
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"error": f"Export failed: {str(e)}"}), 500

api/pdf.py

@@ -4,11 +4,13 @@
 """
 
 import io
+import logging
 import re
 
 from flask import Blueprint, Response, jsonify, request
 
 bp = Blueprint("pdf", __name__)
+_logger = logging.getLogger(__name__)
 
 
 def _safe_text(text: str) -> str:
@@ -168,9 +170,12 @@ def footer(self):
         )
 
     except Exception as e:
-        print(f"Failed to generate PDF: {e}")
-        import traceback
-        traceback.print_exc()
+        _logger.error(
+            "Failed to generate PDF: %s (%s)",
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"error": f"Failed to generate PDF: {str(e)}"}), 500
 
 

api/search.py

@@ -164,7 +164,12 @@ def search():
                             # Drift logged so the operator can see why a chat dropped
                             # out of search results; bad row still skipped so search
                             # keeps returning results from the well-formed ones.
-                            print(f"Schema drift in bubble {bid}: {e}")
+                            _logger.warning(
+                                "Schema drift in bubble %s: %s (%s)",
+                                bid,
+                                e,
+                                type(e).__name__,
+                            )
                         except (json.JSONDecodeError, ValueError):
                             pass
 
@@ -178,7 +183,12 @@ def search():
                     try:
                         composer = Composer.from_dict(json.loads(row["value"]), composer_id=composer_id)
                     except SchemaError as e:
-                        print(f"Schema drift in composer {composer_id}: {e}")
+                        _logger.warning(
+                            "Schema drift in composer %s: %s (%s)",
+                            composer_id,
+                            e,
+                            type(e).__name__,
+                        )
                         continue
                     except (json.JSONDecodeError, TypeError, ValueError):
                         continue

app.py

@@ -4,6 +4,7 @@
 from the Cursor editor's AI chat feature.
 """
 
+import logging
 import os
 import sys
 from datetime import datetime
@@ -35,6 +36,11 @@ def _get_base_path():
 
 
 def create_app(exclusion_rules_path=None):
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s %(funcName)s: %(message)s",
+    )
+
     base = _get_base_path()
     app = Flask(
         __name__,

services/cli_tabs.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import logging
 from datetime import datetime
 
 from flask import current_app, jsonify
 
+_logger = logging.getLogger(__name__)
+
 from utils.cli_chat_reader import list_cli_projects, messages_to_bubbles, traverse_blobs
 from utils.exclusion_rules import build_searchable_text, is_excluded_by_rules
 from utils.workspace_path import get_cli_chats_path
@@ -44,13 +47,25 @@ def _get_cli_workspace_tabs(workspace_id: str):
             try:
                 messages = traverse_blobs(session["db_path"])
             except Exception as e:
-                print(f"CLI: could not read session {session_id}: {e}")
+                _logger.warning(
+                    "Could not read CLI session %s: %s (%s)",
+                    session_id,
+                    e,
+                    type(e).__name__,
+                    exc_info=True,
+                )
                 continue
 
             try:
                 bubbles = messages_to_bubbles(messages, created_ms)
             except Exception as e:
-                print(f"CLI: could not convert session {session_id} to bubbles: {e}")
+                _logger.warning(
+                    "Could not convert CLI session %s to bubbles: %s (%s)",
+                    session_id,
+                    e,
+                    type(e).__name__,
+                    exc_info=True,
+                )
                 continue
             if not bubbles:
                 continue
@@ -113,5 +128,11 @@ def _get_cli_workspace_tabs(workspace_id: str):
         return jsonify({"tabs": tabs})
 
     except Exception as e:
-        print(f"Failed to get CLI workspace tabs: {e}")
+        _logger.error(
+            "Failed to get CLI workspace tabs for %s: %s (%s)",
+            workspace_id,
+            e,
+            type(e).__name__,
+            exc_info=True,
+        )
         return jsonify({"error": "Failed to get CLI workspace tabs"}), 500

tests/test_models_wired_at_read_sites.py

@@ -130,9 +130,11 @@ def test_workspace_tabs_endpoint_calls_bubble_from_dict(self):
 
     def test_bubble_schema_drift_is_logged_not_swallowed_silently(self):
         # CodeRabbit: SchemaError used to be lumped in with JSONDecodeError /
-        # ValueError and skipped silently. Schema drift must now print a
+        # ValueError and skipped silently. Schema drift must now log a
         # `Schema drift in bubble <bid>` line so disappearing bubbles can be
         # traced. The well-formed row still loads alongside.
+        import logging
+
         from app import create_app
         # Seed a deliberately-malformed bubble row that will trip
         # Bubble.from_dict's "expected non-empty str" gate on the bubble_id by
@@ -147,17 +149,14 @@ def test_bubble_schema_drift_is_logged_not_swallowed_silently(self):
         app = create_app()
         app.config["TESTING"] = True
         app.config["EXCLUSION_RULES"] = []
-        import io
-        from contextlib import redirect_stdout
-        captured = io.StringIO()
-        with redirect_stdout(captured):
+        with self.assertLogs("api.search", level="WARNING") as logs:
             client = app.test_client()
             response = client.get("/api/search?q=sentinel-wired")
             self.assertEqual(response.status_code, 200)
-        out = captured.getvalue()
-        self.assertIn("Schema drift in bubble", out,
-            msg=f"expected drift log line, got stdout:\n{out!r}")
-        self.assertIn("bub-bad", out,
+        messages = "\n".join(logs.output)
+        self.assertIn("Schema drift in bubble", messages,
+            msg=f"expected drift log line, got logs:\n{messages!r}")
+        self.assertIn("bub-bad", messages,
             msg="drift log must include the offending bubble id")
 
     def test_workspace_tabs_endpoint_calls_composer_from_dict(self):