python-dead-code-removal

Answer

The defect (TJ-GAP-010): transform_command and transform_exec_command were shipped as part of a command-preprocessing pipeline that has no actual consumer — the "Hermes pre-exec hook" they were meant to back does not exist. They were pure dead weight: unreachable public API, plus helpers only they called, ~50 tests only they exercised, and spec/doc references.

1. Removed the dead functions and their exclusive helpers. Example of the deleted code shape:

# BEFORE (dead) — module: cli/command.py
def transform_command(command: str, context: dict) -> str:
    """Transform a command before exec (Hermes pre-exec hook).

    NOTE: no Hermes pre-exec hook exists; this path is unreachable.
    """
    argv = _split_command(command)
    argv = transform_exec_command(argv, context)
    return _join_command(argv)

def transform_exec_command(argv: list[str], context: dict) -> list[str]:
    for i, tok in enumerate(argv):
        argv[i] = _apply_transform(tok, context)   # exclusive helper
    return argv

def _apply_transform(tok: str, context: dict) -> str:   # helper used only by dead fn
    return tok.replace("$" + context.get("ns", ""), "")

def _split_command(cmd: str) -> list[str]:   # helper used only by dead fn
    return shlex.split(cmd)

# AFTER — the entire block, both private helpers, and the now-unused imports
# (shlex, and any transform-related constants) are gone.

Also removed: the transform_command/transform_exec_command entries from __init__.py exports and any spec references in docs//README that documented the nonexistent hook.

2. Removed the ~50 tests that only exercised the dead path (tests/test_command_transform.py and the transform cases in test_commands.py): the transforms, round-trip split/join cases, and context-expansion cases all went with the functions.

3. Lint fix on the sibling's own new test. The sibling claimed ruff-clean but introduced a test with 2 RUF059 (unused variable in unpacking) violations:

# BEFORE (RUF059) — in the sibling's new test
for command, expected in cases:
    result, _transform = run(command)      # _transform never used
    assert result == expected

original, _rest = transform_pipeline(command)   # _rest never used

# AFTER — unpack only what is needed
for command, expected in cases:
    result = run(command)[0]
    assert result == expected

original, _ = transform_pipeline(command)