In `@tests/integration_tests/test_source_selection.py`:
- Around line 291-300: The tests test_source_invalid_type_string and
test_source_invalid_type_dict use pytest.raises(Exception) which is too broad;
update both to assert the precise exception TypeError raised by collection.get
when _source is the wrong type (string or dict) by replacing
pytest.raises(Exception) with pytest.raises(TypeError) so the tests validate the
correct error class from collection.get.
- Around line 14-25: The test fixture client hardcodes RemoteServerClient
connection details; change the RemoteServerClient(...) call in the client pytest
fixture to read host, port, user, password, and database from environment
variables (e.g., via os.environ.get with sensible defaults) so CI can override
them; update the fixture named client to import os (if needed), use os.getenv
for each parameter, convert port to int when reading, and keep the same
yield/teardown behavior.

In `@src/pyseekdb/client/client_base.py`:
- Around line 2037-2059: The class is calling two missing helpers causing
AttributeError; add implementations for _should_include_core_field(self,
field_name: str, core_column: str, _source: list[str] | None, include_fields:
dict[str,bool], use_source_as_whitelist: bool, alt_name: str | None = None) to
return a boolean by applying the same inclusion rules used by
_build_projection_sql (respecting _source whitelist, include_fields overrides,
and alt_name mapping), and _add_metadata_projection_columns(self, columns:
list[str], _source: list[str] | None, include_fields: dict[str,bool],
use_source_as_whitelist: bool) to append metadata column names to the columns
list according to the include/_source rules (handling nested metadata keys and
any alt naming convention used elsewhere); implement both as methods on the same
class (client_base) so _build_projection_sql can call them without error.

In `@fix_lint.py`:
- Around line 4-8: fix_client_base currently opens
src/pyseekdb/client/client_base.py without checking existence and performs
content.replace() calls without validating whether any replacements occurred;
update fix_client_base to first check os.path.exists(path) and early-return with
a warning if missing, read the file, keep a copy of original content, perform
each replace as it does now, then compare original vs modified and print/log a
warning (or raise) if no changes were made; mirror the same existence check and
post-replace validation pattern used in fix_test so both functions consistently
detect missing files and silent no-op replacements.
- Around line 1-166: The file fix_lint.py is unsafe because fix_client_base()
and fix_test() programmatically rewrite production/tests via fragile
string.replace operations; remove this script from the repo (or move it out of
source control) and commit the intended changes to client_base.py and
tests/integration_tests/test_source_selection.py directly; if you need an
automated transformer keep it as a one-off CLI tool outside the project root and
replace fragile string logic inside fix_client_base() with an AST-aware approach
(e.g., use libcst/lib2to3/ast or rope) and add explicit validation/logging that
each intended replacement occurred (check returned content != original and raise
on mismatch) rather than silently continuing.
- Around line 4-10: The removal of "from .utils import unflatten_dict" breaks
the injected helper _merge_projected_metadata which calls
unflatten_dict(projected_metadata); restore the import or reintroduce an
equivalent definition so unflatten_dict is available to
_merge_projected_metadata, e.g., in the fix_client_base change that edits
client_base.py ensure the import line for unflatten_dict is retained/added back
before _merge_projected_metadata is defined or move a safe import into that
function scope.

In `@src/pyseekdb/client/collection.py`:
- Around line 391-393: The current validation only checks that _source is a list
but not that its elements are strings; update the _source validation (the block
that raises TypeError for non-list _source) to iterate over the list and verify
each element is an instance of str, and if any element is not a string raise a
TypeError that clearly states that _source must be a list of strings and
includes the offending element/index/type; also update the existing error
message to reflect "list of strings or None" and ensure this check is applied
wherever _source is validated in the collection-related functions/methods.

In `@fix_sync.py`:
- Around line 139-146: The replacement is double‑indenting _build_projection_sql
because old_signature lacks the leading indentation; update the replacement
logic in the block that uses old_signature, content.find, new_projection and
next_def so it detects and preserves the existing indentation: locate the actual
indented signature (or capture leading whitespace before the signature match),
compute that indent string, and prefix every line of new_projection with that
indent (or adjust new_projection to remove its own leading 4 spaces) before
splicing into content between idx and next_def (the region ending at
_build_select_clause) to ensure the inserted function has the same indentation
level as the original.

In `@src/pyseekdb/client/client_base.py`:
- Around line 53-67: The unflatten_dict function can crash when a path like
"metadata.a" exists as a scalar and another key "metadata.a.b" arrives; update
unflatten_dict to guard during traversal by checking if target[part] exists and
is not a dict, and if so replace it with a dict (e.g., target[part] = {"_value":
previous_scalar}) before continuing traversal so nested assignments won't raise
TypeError; modify the loop inside unflatten_dict where it walks parts (refer to
the variables result, target, parts and the for part in parts[:-1] block) to
perform this check-and-coerce behavior and then assign target[parts[-1]] = value
as before.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@tests/test_detect_db_type_and_version.py`:
- Line 72: Remove the unnecessary f-string prefix from static print statements
in tests/test_detect_db_type_and_version.py (e.g. change print(f"\n✅
Successfully detected seekdb Server") to a plain string) — update all similar
occurrences mentioned (the prints at the other noted locations with static
messages) so they use print("...") instead of print(f"...") to avoid Ruff F541.
- Around line 57-79: The test currently wraps assertions and detection logic in
a broad try/except which swallows AssertionError; update the block around
client._server.execute and client._server.detect_db_type_and_version so that
assertion failures are not caught: either remove the try/except entirely or
narrow it to only catch connection-related exceptions (e.g., ConnectionError or
a client-specific connection exception) and call pytest.fail only for those;
ensure you reference client._server.execute,
client._server.detect_db_type_and_version, SERVER_HOST, SERVER_PORT and leave
normal AssertionError/pytest assertion behavior to surface so test failures show
real tracebacks.
- Around line 39-79: Mark the DB-backed tests (e.g., test_server_detect_seekdb)
as integration-only and skip them when the target endpoints are unreachable: add
a connectivity check (e.g., a helper is_reachable(host, port) that attempts a
short socket connection or uses the existing client to ping) and use
pytest.mark.skipif(not is_reachable(SERVER_HOST, SERVER_PORT),
reason="integration test: DB endpoint not reachable") or a custom pytest marker
like `@pytest.mark.integration` combined with a skipif; apply this pattern to
test_server_detect_seekdb and the other test functions referenced (lines
~80-120, 121-153, 154-189) so they only run when the host/port are reachable.
Ensure the check uses SERVER_HOST and SERVER_PORT and that the skip message
explains the dependency on a live SeekDB/OceanBase endpoint.