Add multi-file support and --filename annotation option to show-paths

Accept multiple files as positional arguments (nargs="*") and add
--filename option (auto/prefix/name) to control how filenames appear
in output. 'auto' (default) adds filename: prefix only for multiple
files, preserving backward compatibility. 'prefix' always prepends
filename: to lines. 'name' prints filename as a header before hits.

Co-Authored-By: Claude Code 2.1.63 / Claude Opus 4.6 <noreply@anthropic.com>

Author: yarikoptic

bin/show-paths

@@ -136,42 +136,60 @@ def get_paths(lines):
     return paths
 
 
-def print_inline(paths, lines, use_color):
+def print_inline(paths, lines, use_color, prefix=""):
     """Print paths and matched lines in inline format."""
     for line_num, path in paths:
         path_str = ".".join([p[0] for p in path[:-1]])
         line = lines[line_num].rstrip()
         if use_color:
             path_str = colored(path_str, attrs=["dark"])
             line = colored(line, "red")
-        print(f"{line_num}: {path_str} {line}")
+        print(f"{prefix}{line_num}: {path_str} {line}")
 
 
-def print_full_lines(paths, lines, use_color):
+def print_full_lines(paths, lines, use_color, prefix=""):
     """Print paths and matched lines in full-lines format."""
     printed = set()
     for line_num, path in paths:
         # in simplest case -- print all lines of the path
         for key, indent, i in path[:-1]:
             line_colored = colored(lines[i], attrs=["dark"]) if use_color else lines[i]
             if i not in printed:
-                print(f"{i}  {line_colored}")
+                print(f"{prefix}{i}  {line_colored}")
                 printed.add(i)
         line_colored = colored(lines[line_num], "red") if use_color else lines[line_num]
-        print(f"{line_num}: {line_colored}")
+        print(f"{prefix}{line_num}: {line_colored}")
         printed.add(line_num)
 
 
+def filter_paths(lines, regex=None, line_numbers=None):
+    """Get and filter indentation-based paths for given lines."""
+    paths = get_paths(lines)
+
+    if regex:
+        paths = [
+            (line_num, path)
+            for line_num, path in paths
+            if regex.search(lines[line_num])
+        ]
+
+    if line_numbers:
+        nums = set(line_numbers)
+        paths = [
+            (line_num, path) for line_num, path in paths if line_num in nums
+        ]
+
+    return paths
+
+
 def main():
     parser = argparse.ArgumentParser(
         description=__doc__, formatter_class=ColoredHelpFormatter
     )
     parser.add_argument(
         "file",
-        nargs="?",
-        type=argparse.FileType("r"),
-        default=sys.stdin,
-        help="Input file to process (default: stdin)",
+        nargs="*",
+        help="Input file(s) to process (default: stdin)",
     )
     parser.add_argument(
         "-e", "--regex", type=str, help="Regular expression to match lines"
@@ -196,6 +214,13 @@ def main():
         default="auto",
         help="Color output: 'auto' (default), 'on', or 'off'",
     )
+    parser.add_argument(
+        "--filename",
+        choices=["auto", "prefix", "name"],
+        default="auto",
+        help="How to annotate output with filename: 'auto' (prefix when multiple files),"
+        " 'prefix' (prepend filename: to each line), 'name' (print filename header)",
+    )
 
     args = parser.parse_args()
 
@@ -209,36 +234,40 @@ def main():
     # Compile regex if provided
     regex = re.compile(args.regex) if args.regex else None
 
-    # Read lines from the file
-    lines = args.file.readlines()
-    lines = [line.rstrip() for line in lines]
+    # Determine file list: use provided files or stdin
+    files = args.file if args.file else [None]  # None means stdin
 
-    # Get paths for all lines
-    paths = get_paths(lines)
+    # Resolve filename display mode
+    filename_mode = args.filename
+    if filename_mode == "auto":
+        filename_mode = "prefix" if len(files) > 1 else None
 
-    # Filter by regex if provided
-    if args.regex:
-        regex = re.compile(args.regex)
-        paths = [
-            (line_num, path)
-            for line_num, path in paths
-            if regex.search(lines[line_num])
-        ]
+    for filepath in files:
+        if filepath is None:
+            lines = sys.stdin.readlines()
+            fname = "<stdin>"
+        else:
+            with open(filepath) as f:
+                lines = f.readlines()
+            fname = filepath
 
-    # Filter by line numbers if provided
-    if args.line_number:
-        line_numbers = set(args.line_number)
-        paths = [
-            (line_num, path) for line_num, path in paths if line_num in line_numbers
-        ]
+        lines = [line.rstrip() for line in lines]
+
+        paths = filter_paths(lines, regex=regex, line_numbers=args.line_number)
+        if not paths:
+            continue
+
+        prefix = f"{fname}:" if filename_mode == "prefix" else ""
+
+        if filename_mode == "name":
+            print(fname)
 
-    # Print based on the chosen format
-    if args.format == "inline":
-        print_inline(paths, lines, use_color)
-    elif args.format == "full-lines":
-        print_full_lines(paths, lines, use_color)
-    else:
-        raise ValueError(args.format)
+        if args.format == "inline":
+            print_inline(paths, lines, use_color, prefix=prefix)
+        elif args.format == "full-lines":
+            print_full_lines(paths, lines, use_color, prefix=prefix)
+        else:
+            raise ValueError(args.format)
 
 
 if __name__ == "__main__":

tests/test_show_paths.py

@@ -507,3 +507,164 @@ def test_show_paths_regex_case_sensitive():
     assert result_lower.stdout.strip() == ""
     # Correct case should find the class
     assert "MyClass" in result_correct.stdout
+
+
+@pytest.mark.ai_generated
+def test_show_paths_multiple_files():
+    """Test show-paths with multiple files."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        str(DATA_DIR / "sample.json"),
+        "-e",
+        "target_field",
+        "--color",
+        "off",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Only sample.json has target_field, so output should have its prefix
+    assert "sample.json:" in output
+    assert "target_field" in output
+    # sample.py has no match, so it shouldn't appear
+    assert "sample.py:" not in output
+
+
+@pytest.mark.ai_generated
+def test_show_paths_multiple_files_both_match():
+    """Test show-paths with multiple files where both have matches."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        str(DATA_DIR / "sample.xml"),
+        "-e",
+        "target",
+        "--color",
+        "off",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Both files have "target" somewhere
+    assert "sample.py:" in output
+    assert "sample.xml:" in output
+
+
+@pytest.mark.ai_generated
+def test_show_paths_multiple_files_auto_prefix():
+    """Test that auto mode adds filename prefix for multiple files."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        str(DATA_DIR / "sample.json"),
+        "-e",
+        "def",
+        "--color",
+        "off",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Auto mode with multiple files should prefix with filename
+    for line in output.strip().split("\n"):
+        assert "sample.py:" in line
+
+
+@pytest.mark.ai_generated
+def test_show_paths_single_file_auto_no_prefix():
+    """Test that auto mode does NOT add filename prefix for single file."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        "-e",
+        "def",
+        "--color",
+        "off",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Auto mode with single file: no filename prefix
+    for line in output.strip().split("\n"):
+        assert not line.startswith("sample.py:")
+
+
+@pytest.mark.ai_generated
+def test_show_paths_filename_prefix_single_file():
+    """Test --filename=prefix forces prefix even with single file."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        "-e",
+        "find_me",
+        "--color",
+        "off",
+        "--filename",
+        "prefix",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    assert "sample.py:" in output
+    assert "find_me" in output
+
+
+@pytest.mark.ai_generated
+def test_show_paths_filename_name_mode():
+    """Test --filename=name prints filename header before hits."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        str(DATA_DIR / "sample.json"),
+        "-e",
+        "target",
+        "--color",
+        "off",
+        "--filename",
+        "name",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    lines = output.strip().split("\n")
+    # Should have filename as standalone header line
+    py_path = str(DATA_DIR / "sample.py")
+    json_path = str(DATA_DIR / "sample.json")
+    assert py_path in lines
+    assert json_path in lines
+    # After each header, lines should NOT have filename prefix
+    # Find the line after the header
+    py_idx = lines.index(py_path)
+    assert ":" in lines[py_idx + 1]  # line number format
+    assert not lines[py_idx + 1].startswith(py_path + ":")
+
+
+@pytest.mark.ai_generated
+def test_show_paths_filename_name_skips_no_hits():
+    """Test --filename=name does not print header for files with no hits."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.py"),
+        str(DATA_DIR / "sample.json"),
+        "-e",
+        "target_field",
+        "--color",
+        "off",
+        "--filename",
+        "name",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Only sample.json has target_field
+    assert str(DATA_DIR / "sample.json") in output
+    assert str(DATA_DIR / "sample.py") not in output
+
+
+@pytest.mark.ai_generated
+def test_show_paths_multiple_files_full_lines():
+    """Test multiple files with full-lines format and prefix."""
+    result = run_show_paths(
+        str(DATA_DIR / "sample.json"),
+        str(DATA_DIR / "sample.xml"),
+        "-e",
+        "target",
+        "-f",
+        "full-lines",
+        "--color",
+        "off",
+    )
+    assert result.returncode == 0
+    output = result.stdout
+    # Both context lines and match lines should have the prefix
+    json_lines = [l for l in output.split("\n") if l.startswith(str(DATA_DIR / "sample.json:"))]
+    xml_lines = [l for l in output.split("\n") if l.startswith(str(DATA_DIR / "sample.xml:"))]
+    assert len(json_lines) > 0
+    assert len(xml_lines) > 0