Fix: Add all/brief output options to introspect

Co-Authored-By: Codex <codex@openai.com>

Author: heikkitoivonen

scripts/introspect.py

@@ -134,22 +134,29 @@ def build_item_list() -> list[tuple[str, object]]:
     return items
 
 
-def format_module(module: ModuleType) -> list[str]:
+def format_module(module: ModuleType, brief: bool) -> list[str]:
     """Format a module's contents."""
-    lines = ["Type: module"]
     contents = get_module_contents(module)
+    if brief:
+        return [f"  {c}" for c in contents]
+
+    lines = ["Type: module"]
     if contents:
         lines.append("")
         lines.append("Contents:")
         lines.extend(f"  {c}" for c in contents)
     return lines
 
 
-def format_class(cls: type) -> list[str]:
+def format_class(cls: type, brief: bool) -> list[str]:
     """Format a class's methods and attributes."""
-    lines = ["Type: class"]
     methods, attributes = get_direct_members(cls)
 
+    if brief:
+        return [f"  {name}" for name in (methods + attributes)]
+
+    lines = ["Type: class"]
+
     if methods:
         lines.append("")
         lines.append("Methods:")
@@ -167,21 +174,31 @@ def format_class(cls: type) -> list[str]:
     return lines
 
 
-def format_item(name: str, obj: object, next_name: str | None) -> str:
+def format_item(
+    name: str,
+    obj: object,
+    next_name: str | None,
+    *,
+    brief: bool,
+    include_next: bool,
+) -> str:
     """Format an item for output."""
-    lines = [f"=== {name} ==="]
+    lines = [name] if brief else [f"=== {name} ==="]
 
     if isinstance(obj, ModuleType):
-        lines.extend(format_module(obj))
+        lines.extend(format_module(obj, brief))
     elif isinstance(obj, type):
-        lines.extend(format_class(obj))
+        lines.extend(format_class(obj, brief))
     elif callable(obj):
-        lines.append("Type: function")
+        if not brief:
+            lines.append("Type: function")
     else:
-        lines.append(f"Type: {type(obj).__name__}")
+        if not brief:
+            lines.append(f"Type: {type(obj).__name__}")
 
-    lines.append("")
-    lines.append(f"Next: {next_name}" if next_name else "This is the last item.")
+    if include_next and not brief:
+        lines.append("")
+        lines.append(f"Next: {next_name}" if next_name else "This is the last item.")
 
     return "\n".join(lines)
 
@@ -194,7 +211,7 @@ def find_item_index(items: list[tuple[str, object]], target: str) -> int | None:
     return None
 
 
-def handle_next(items: list[tuple[str, object]], target: str) -> None:
+def handle_next(items: list[tuple[str, object]], target: str, *, brief: bool) -> None:
     """Handle --next command."""
     found_idx = find_item_index(items, target)
 
@@ -211,7 +228,7 @@ def handle_next(items: list[tuple[str, object]], target: str) -> None:
     next_idx = found_idx + 1
     name, obj = items[next_idx]
     next_name = items[next_idx + 1][0] if next_idx + 1 < len(items) else None
-    print(format_item(name, obj, next_name))
+    print(format_item(name, obj, next_name, brief=brief, include_next=True))
 
 
 def main() -> None:
@@ -222,19 +239,38 @@ def main() -> None:
     group.add_argument("--start", action="store_true", help="Output the first item")
     group.add_argument("--next", metavar="NAME", help="Output the item after NAME")
     group.add_argument("--count", action="store_true", help="Output total item count")
+    group.add_argument("--all", action="store_true", help="Output all items")
+    parser.add_argument(
+        "--brief",
+        action="store_true",
+        help="Output only names (no descriptive text)",
+    )
 
     args = parser.parse_args()
 
     items = build_item_list()
 
     if args.count:
         print(f"Total items: {len(items)}")
+    elif args.all:
+        formatted = [
+            format_item(
+                name,
+                obj,
+                None,
+                brief=args.brief,
+                include_next=False,
+            )
+            for name, obj in items
+        ]
+        separator = "\n" if args.brief else "\n\n"
+        print(separator.join(formatted))
     elif args.start:
         name, obj = items[0]
         next_name = items[1][0] if len(items) > 1 else None
-        print(format_item(name, obj, next_name))
+        print(format_item(name, obj, next_name, brief=args.brief, include_next=True))
     else:
-        handle_next(items, args.next)
+        handle_next(items, args.next, brief=args.brief)
 
 
 if __name__ == "__main__":

tests/test_introspect.py

@@ -1,5 +1,6 @@
 """Unit tests for the introspection script."""
 
+import sys
 from unittest.mock import MagicMock
 
 from scripts.introspect import (
@@ -13,6 +14,7 @@
     get_module_contents,
     get_stdlib_modules,
     is_public,
+    main,
     should_include_member,
 )
 
@@ -253,37 +255,46 @@ class TestFormatModule:
     def test_includes_type_line(self) -> None:
         import collections
 
-        lines = format_module(collections)
+        lines = format_module(collections, False)
         assert "Type: module" in lines
 
     def test_includes_contents_header(self) -> None:
         import collections
 
-        lines = format_module(collections)
+        lines = format_module(collections, False)
         assert "Contents:" in lines
 
     def test_includes_module_contents(self) -> None:
         import collections
 
-        lines = format_module(collections)
+        lines = format_module(collections, False)
         output = "\n".join(lines)
         assert "Counter" in output
         assert "deque" in output
 
+    def test_brief_outputs_names_only(self) -> None:
+        import collections
+
+        lines = format_module(collections, True)
+        output = "\n".join(lines)
+        assert "Type: module" not in output
+        assert "Contents:" not in output
+        assert "Counter" in output
+
 
 class TestFormatClass:
     """Tests for format_class function."""
 
     def test_includes_type_line(self) -> None:
-        lines = format_class(list)
+        lines = format_class(list, False)
         assert "Type: class" in lines
 
     def test_includes_methods_header(self) -> None:
-        lines = format_class(list)
+        lines = format_class(list, False)
         assert "Methods:" in lines
 
     def test_includes_class_methods(self) -> None:
-        lines = format_class(list)
+        lines = format_class(list, False)
         output = "\n".join(lines)
         assert "append" in output
         assert "pop" in output
@@ -292,44 +303,110 @@ def test_empty_class_shows_no_members_message(self) -> None:
         class EmptyClass:
             pass
 
-        lines = format_class(EmptyClass)
+        lines = format_class(EmptyClass, False)
         assert "(no public direct members)" in lines
 
+    def test_brief_outputs_names_only(self) -> None:
+        lines = format_class(list, True)
+        output = "\n".join(lines)
+        assert "Type: class" not in output
+        assert "Methods:" not in output
+        assert "append" in output
+
 
 class TestFormatItem:
     """Tests for format_item function."""
 
     def test_includes_name_header(self) -> None:
-        output = format_item("builtins.list", list, "builtins.locals")
+        output = format_item(
+            "builtins.list",
+            list,
+            "builtins.locals",
+            brief=False,
+            include_next=True,
+        )
         assert "=== builtins.list ===" in output
 
     def test_includes_next_line(self) -> None:
-        output = format_item("builtins.list", list, "builtins.locals")
+        output = format_item(
+            "builtins.list",
+            list,
+            "builtins.locals",
+            brief=False,
+            include_next=True,
+        )
         assert "Next: builtins.locals" in output
 
     def test_last_item_message(self) -> None:
-        output = format_item("builtins.list", list, None)
+        output = format_item("builtins.list", list, None, brief=False, include_next=True)
         assert "This is the last item." in output
 
     def test_formats_module(self) -> None:
         import collections
 
-        output = format_item("collections", collections, "collections.Counter")
+        output = format_item(
+            "collections",
+            collections,
+            "collections.Counter",
+            brief=False,
+            include_next=True,
+        )
         assert "Type: module" in output
 
     def test_formats_class(self) -> None:
-        output = format_item("builtins.list", list, "builtins.locals")
+        output = format_item(
+            "builtins.list",
+            list,
+            "builtins.locals",
+            brief=False,
+            include_next=True,
+        )
         assert "Type: class" in output
         assert "Methods:" in output
 
     def test_formats_function(self) -> None:
-        output = format_item("builtins.len", len, "builtins.license")
+        output = format_item(
+            "builtins.len",
+            len,
+            "builtins.license",
+            brief=False,
+            include_next=True,
+        )
         assert "Type: function" in output
 
     def test_formats_other_types(self) -> None:
-        output = format_item("builtins.True", True, "builtins.tuple")
+        output = format_item(
+            "builtins.True",
+            True,
+            "builtins.tuple",
+            brief=False,
+            include_next=True,
+        )
         assert "Type: bool" in output
 
+    def test_brief_formats_name_only_header(self) -> None:
+        output = format_item(
+            "builtins.list",
+            list,
+            "builtins.locals",
+            brief=True,
+            include_next=True,
+        )
+        assert output.splitlines()[0] == "builtins.list"
+        assert "Type:" not in output
+        assert "Next:" not in output
+
+    def test_brief_formats_function_as_name_only(self) -> None:
+        output = format_item(
+            "builtins.len",
+            len,
+            "builtins.license",
+            brief=True,
+            include_next=True,
+        )
+        assert output.strip() == "builtins.len"
+        assert "Type:" not in output
+
 
 class TestFindItemIndex:
     """Tests for find_item_index function."""
@@ -364,7 +441,13 @@ def test_full_workflow(self) -> None:
         # First item should be formattable
         first_name, first_obj = items[0]
         second_name = items[1][0] if len(items) > 1 else None
-        output = format_item(first_name, first_obj, second_name)
+        output = format_item(
+            first_name,
+            first_obj,
+            second_name,
+            brief=False,
+            include_next=True,
+        )
         assert first_name in output
 
         # Should be able to find items
@@ -373,7 +456,13 @@ def test_full_workflow(self) -> None:
 
     def test_builtins_list_format(self) -> None:
         """Test that builtins.list formats correctly with expected methods."""
-        output = format_item("builtins.list", list, "builtins.locals")
+        output = format_item(
+            "builtins.list",
+            list,
+            "builtins.locals",
+            brief=False,
+            include_next=True,
+        )
 
         assert "=== builtins.list ===" in output
         assert "Type: class" in output
@@ -390,3 +479,11 @@ def test_builtins_list_format(self) -> None:
         assert "reverse" in output
         assert "sort" in output
         assert "Next: builtins.locals" in output
+
+    def test_all_brief_has_no_blank_lines(self, monkeypatch, capsys) -> None:
+        monkeypatch.setattr(sys, "argv", ["introspect.py", "--all", "--brief"])
+        main()
+        output = capsys.readouterr().out.strip()
+        lines = output.splitlines()
+        assert len(lines) > 1
+        assert "" not in lines