• Close entry editor automatically when last library is closed
• Improve GroupsParser to skip unknown group types gracefully
• Add comprehensive tests for GroupsParser behavior
• Update CHANGELOG documenting the entry editor fix

Close entry editor when no library active

• Added close() method call in the activeTabProperty listener's else branch
• Handles the case when no library tab is active (zero libraries open)
• Ensures entry editor closes automatically when last library is closed

jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java

Skip unknown groups instead of throwing exception

• Changed fromString() method to return null for unknown group types instead of throwing
 ParseException
• Added null check in importGroups() to skip unknown groups with continue statement
• Replaced exception throwing with warning log message for unknown group types
• Removed inline comments for code clarity

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java

Add tests for unknown group handling

• Changed test fromStringUnknownGroupThrowsException() to fromStringReturnsNullForUnknownGroup()
 with assertNull assertion
• Added assertNotNull() checks in multiple tests to verify non-null parsing results
• Added new test unknownGroupTypeIsSkipped() to verify unknown groups are skipped during import
• Added ArrayList import for test implementation

jablib/src/test/java/org/jabref/logic/importer/util/GroupsParserTest.java

Description

GroupsParser.fromString now returns null for unknown group types, but the method contract is not
made null-safe (e.g., via JSpecify @Nullable or an Optional return type). This can lead to
unclear/null-unsafe usage and violates the project’s null-handling guidance.

Code

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[R140-141]

+        LOGGER.warn("Unknown group type, skipping: {}", input);
+        return null;

Evidence

PR Compliance requires explicit nullability contracts (JSpecify / avoiding null) and correct
Optional/null usage. The changed code path logs and returns null for unknown group types without
any nullability contract in the signature/Javadoc.

AGENTS.md
AGENTS.md
jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[98-142]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`GroupsParser.fromString(...)` now returns `null` for unknown group types, but the method signature/Javadoc does not declare nullable behavior using JSpecify (or an `Optional` return type). This makes the API contract unclear and can lead to null-unsafe usage.

## Issue Context
The PR changed the behavior for unknown group types from throwing a `ParseException` to logging and returning `null`.

## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[98-142]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

GroupsParser.importGroups can now return null when all group lines are skipped (unknown types),
but MetaDataParser passes that value into MetaData.setGroups(@NonNull ...), leading to a
NullPointerException during metadata parsing.

Code

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[R73-77]

                int level = Integer.parseInt(string.substring(0, spaceIndex));
                AbstractGroup group = GroupsParser.fromString(string.substring(spaceIndex + 1), keywordSeparator, fileMonitor, metaData, userAndHost);
+                if (group == null) {
+                    continue;
+                }

Evidence

importGroups initializes root to null and returns it without ensuring it was set; with the new
if (group == null) { continue; }, all lines can be skipped leaving root null. MetaDataParser
unconditionally calls metaData.setGroups(...), and MetaData.setGroups requires a non-null root
and dereferences it immediately.

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[54-96]
jablib/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java[132-145]
jablib/src/main/java/org/jabref/model/metadata/MetaData.java[110-117]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
`GroupsParser.importGroups(...)` can return `null` when unknown group types are skipped, and this `null` is passed to `MetaData.setGroups(@NonNull ...)`, causing an NPE.

### Issue Context
Unknown group types are now mapped to `null` by `GroupsParser.fromString(...)`. When the first/root group is unknown (or all groups are unknown), `root` stays `null` and is returned.

### Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[54-96]
- jablib/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java[141-145]

### Expected fix shape
- Make `importGroups` always return a non-null `GroupTreeNode` (e.g., `GroupTreeNode.fromGroup(GroupsFactory.createAllEntriesGroup())`) when parsing yields no root, OR
- Change the API to return `Optional<GroupTreeNode>` and adjust `MetaDataParser` accordingly, OR
- Throw a `ParseException` when `root` is still null at end (so the existing parse-failure flow is used).

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

When importGroups skips an unknown group, it does not adjust the cursor according to the skipped
node’s level, so subsequent groups can be attached under the wrong parent, corrupting the imported
groups tree.

Code

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[R73-85]

                int level = Integer.parseInt(string.substring(0, spaceIndex));
                AbstractGroup group = GroupsParser.fromString(string.substring(spaceIndex + 1), keywordSeparator, fileMonitor, metaData, userAndHost);
+                if (group == null) {
+                    continue;
+                }
                GroupTreeNode newNode = GroupTreeNode.fromGroup(group);
                if (cursor == null) {
-                    // create new root
                    cursor = newNode;
                    root = cursor;
                } else {
-                    // insert at desired location
                    while ((level <= cursor.getLevel()) && (cursor.getParent().isPresent())) {
                        cursor = cursor.getParent().get();
                    }

Evidence

The new continue happens before the level-based cursor rewind (`while (level <= cursor.getLevel())
...`). If an unknown group appears at a shallower level than the current cursor, skipping it leaves
cursor too deep, and the next group’s insertion will be based on the wrong ancestor. Example:
levels 0 root, 1 A, 2 B, 1 <unknown skipped>, 2 C will attach C under A (due to cursor
rewinding from B to A) instead of under root (the intended parent for a level-1 sibling’s
children when that sibling is skipped).

jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[54-89]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
Skipping unknown groups with `continue` prevents `cursor` from being updated for that line’s level, which can misplace subsequent nodes in the tree.

### Issue Context
`importGroups` uses indentation levels to decide where to attach the next node. The current algorithm assumes every level line yields a node; skipping violates that assumption.

### Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/importer/util/GroupsParser.java[54-89]

### Expected fix shape
Implement one of:
- Move the `while ((level <= cursor.getLevel()) ... )` cursor-rewind *before* the `group == null` early-continue so cursor reflects the current line’s intended depth even when skipped.
- Preferably, maintain a `List<GroupTreeNode> lastNodeAtLevel` (or stack) so `parent = lastNodeAtLevel[level-1]` (falling back to the nearest lower non-null level), and on skip update the stack entry for that level appropriately.
- Add/adjust a unit test that includes an unknown group at a shallower level than the current cursor and verifies the resulting parent/child relationships.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Description

The entry editor closing behavior was changed, but no automated test was added/updated to prevent
regressions. This weakens confidence that the editor reliably closes when the last library is closed
across future changes.

Code

jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java[R163-166]

            } else {
                this.allPossibleTabs.clear();
+                close();
            }

Evidence

PR Compliance requires behavior changes to be covered by updated or new tests when applicable. The
PR introduces new closing behavior via close() in EntryEditor, while the PR checklist indicates
tests were not fully added.

AGENTS.md
jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java[155-167]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
A user-visible behavior change was made (entry editor closes when the last library is closed), but there is no automated test to lock in the expected behavior.

## Issue Context
`EntryEditor` now calls `close()` when `activeTabProperty()` becomes empty.

## Fix Focus Areas
- jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java[155-167]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools