Skip to content

Groups panel mirrors the directory structure (phase 4, #10930) - #740

Open
koppor wants to merge 22 commits into
directory-write-backfrom
directory-groups
Open

koppor wants to merge 22 commits into
directory-write-backfrom
directory-groups

Conversation

@koppor

@koppor koppor commented Jul 14, 2026 •

Copy link
Copy Markdown
Member

📚 Directory-as-library stack — bottom → top, each builds on the one below:

  1. Programmatic Hayagriva writer (directory-as-library, phase 0) #736 · Hayagriva YAML writer
  2. Open folder as library (directory as library, phase 1) #737 · Open folder as library
  3. Live inbound sync for directory libraries (phase 2) #738 · Inbound file sync
  4. Write-back to Hayagriva sidecars (directory as library, phase 3) #739 · Write-back to sidecars
  5. Groups panel mirrors the directory structure (phase 4, #10930) #740 · Directory-structure groups ← this PR
  6. Pattern-driven pair renames for directory libraries (phase 5a) #741 · Pattern-driven pair renames
  7. Mirror directory libraries into a .bib with git-sync merge-back #743 · .bib mirror + merge-back
  8. Convert .bib libraries into directory libraries #744 · Convert .bib → directory
  9. Make directory libraries reachable through the REST API #745 · REST API support
  10. Split DirectoryLibrarySynchronizer into collaborators #760 · Split the synchronizer

Related issues and pull requests

Phase 4 of the "directory as library" plan (PLAN.md), stacked on #739 (base branch directory-write-back). Implements the directory-library part of JabRef#10930 (dynamic groups mirroring the file system) — not closing it, since the issue also covers plain .bib libraries.

PR Description

🤖 The groups panel of a directory library now mirrors its folder tree: each subdirectory appears as a group holding the entries whose files live there, nested folders included. The groups are read-only and follow external file changes as they happen. Saving the library as a .bib still works — parsed back outside a directory library, the groups are simply empty.

jabref-contrib-policy:4.2:reviewed​:ok

Analogies

Like honey stored cell by cell, every entry sits visibly in the comb it came from — the folder becomes the group. Like a chocolate bar's grooves, the directory tree gives natural break lines that the groups panel simply traces. And like the moon mirrored on water, the panel is a live reflection: move the folder underneath, and the image follows without anyone redrawing it.

Steps to test

  1. Open a folder with subdirectories as library (File > Open folder as library...), show the groups panel (View > Groups).
  2. The library's folder appears as a group with one subgroup per subdirectory; selecting a subgroup filters the table to the entries whose files live there (hit counts shown):

Groups panel mirroring the folder structure, conference selected filters to its entry

  1. Rename or add a .yml in a subdirectory externally — the tree and counts follow.

Guarded by DirectoryStructureGroupTest (chain building, tree merging, containment semantics, serialize/parse round trip) and a scanner test asserting the installed groups tree.

AI usage

Claude Code (model claude-fable-5).

AI CHECKLIST.md walkthrough

1. Code self-review

  • JSpecify conventions followed (model group classes match their unannotated neighbors); Optional chains for the lookup; no Objects.requireNonNull.
  • No broad catches, no RuntimeException/IllegalStateException thrown.
  • Modern Java (pattern-matching switch labels, records untouched); Markdown Javadoc; no commented-out code.
  • [/] User-facing text: group names are folder names; the "All entries" root reuses GroupsFactory's localized name.
  • [/] Security: no HTML output.
  • Tests assert object contents, plain JUnit, no @DisplayName.

2. Verification commands

  • ./gradlew :jablib:check — only the known environmental Remote*Test port-conflict failures on this machine (green on CI).
  • ./gradlew :jablib:checkstyleMain :jablib:checkstyleTest :jabgui:checkstyleMain.
  • ./gradlew :jablib:modernizer, ./gradlew traceRequirements (new req~directory-library.groups~1 covered), ./gradlew :rewriteRun clean.
  • npx markdownlint-cli2 on changed Markdown.
  • [/] IntelliJ-format docker image — not runnable on this machine; CI format job is the backstop.

3. Documentation

  • CHANGELOG.md entry (TODO replaced with this PR's link after creation).
  • Requirement req~directory-library.groups~1 added with impl marker.
  • [/] ADR — ADR-0072 already sketches this phase (groups section).

4. Pull request

  • Body from the template, all sections filled, HTML comments removed, created from a body file via gh api (stacked cross-repo).
  • CHANGELOG TODO replaced after creation, committed and pushed.

Checklist

  • I own the copyright of the code submitted and I license it under the MIT license
  • If AI tools were used, I disclosed them in the "AI usage" section and reviewed, understood, and take full ownership of all AI-generated code
  • I manually tested my changes in running JabRef (opened the demo folder on the X display: the groups panel showed the folder tree, selecting a folder group filtered the table with correct hit counts; see screenshot)
  • I added JUnit tests for changes (if applicable)
  • I added screenshots in the PR description (if change is visible to the user)
  • [/] I added a screenshot in the PR description showing a library with a single entry with me as author and as title the issue number
  • I added one sentence (max 20 words) to CHANGELOG.md describing the change from the user's point of view (if the change is visible to the user)
  • I checked the user documentation for up to dateness and submitted a pull request to our user documentation repository — deferred until the feature stabilizes; tracked in PLAN.md phase 5

🤖 Generated with Claude Code

koppor and others added 2 commits July 14, 2026 10:44
An open directory library installs a DirectoryStructureGroup (issue
10930): like the other automatic groups it materializes its subgroups
from the entries — one DirectoryPathGroup per subdirectory, matching
every entry whose source file lives in that directory or below. The
lookup reads the live catalog, and the synchronizer invalidates the
groups view after structural changes, so the tree follows external
renames and additions. The directory groups are read-only in the UI;
serialization support keeps "Save as" working (parsed back without a
library, the group simply stays empty).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
koppor and others added 8 commits July 17, 2026 02:00
# Conflicts:
#	jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java
Resync layer 5 of the stack (no conflicts).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcHNMt9fPWnpYaHheFvry
…asses

The groups panel rebuilds the directory subgroups when the synchronizer invalidates the groups binding; the group classes are null-marked, drop the redundant equality override, and build the subgroup chain without null tracking.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vr3E1Gg5DRU4LQDDVnhPys
# Conflicts:
#	jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java
#	jablib/src/test/java/org/jabref/logic/directorylibrary/DirectoryLibraryScannerTest.java
Fixes the CI format check.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcHNMt9fPWnpYaHheFvry
Resync with upstream (no conflicts).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcHNMt9fPWnpYaHheFvry
Upstream added a 0071 ADR after this stack claimed the number, so the
MADR duplicate-ID check failed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
@qodo-free-for-open-source-projects

qodo-free-for-open-source-projects Bot commented Nov 15, 2026 •

Copy link
Copy Markdown

Code Review by Qodo

🐞 Bugs (9) 📘 Rule violations (1) 📎 Requirement gaps (1)

Grey Divider


Action required

1. Selecting the library folder hides its entries 🐞 Bug
Description
DirectoryStructureGroup inherits an always-false contains method, and installDirectoryGroups
creates it with an independent hierarchy. When a user selects the library-folder row, neither its
matching directory children nor its files contribute to the table filter or hit count.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[145]

+        groupsRoot.addSubgroup(new DirectoryStructureGroup(rootName, GroupHierarchyType.INDEPENDENT, sourceFileLookup));
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Selecting the library-folder group filters out every entry because its independent matcher inherits `AutomaticGroup.contains`, which returns false.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/model/groups/DirectoryStructureGroup.java[20-37]
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[140-146]
## Recommended Fix
Make the directory-structure group's membership match entries resolved inside its library root, including root-level files, while leaving parsed groups with an empty lookup empty. Test selection and counts for the folder-root row.

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


2. Each file change leaks a set of group view models 🐞 Bug
Description
refreshGroup replaces generated directory children with children.setAll(...) without disposing
the old GroupNodeViewModel instances, leaving their database-change and search-index listeners
registered. Structural changes reported by the synchronizer, and search-group index updates that
invalidate groupsBinding, can repeatedly rebuild the children, leaving old models attached to
process later database changes.
Code

jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[R395-397]

+            if (groupNode.getGroup() instanceof DirectoryStructureGroup directoryStructureGroup) {
+                children.setAll(automaticSubgroups(directoryStructureGroup));
+            }
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`refreshGroup` replaces directory subgroup view models without disposing the old children. Their database and event-bus listeners remain registered, so repeated rebuilds leave old models processing later changes.
## Fix Focus Areas
- jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[311-333]
- jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[385-398]
## Recommended Fix
Copy the current children and build the replacement list. Preserve any selection that refers to replaced children, call `children.setAll(newChildren)`, then call `dispose()` on each old child that was not reused. Where possible, reuse existing child view models or skip the rebuild when the new subgroup tree equals the current one.

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



Remediation recommended

3. One malformed file link breaks folder group matching 🐞 Bug ⭐ New
Description
The PDF fallback in sourceFileLookup calls Path.of(linkedFile.getLink()) with no guard, and that
lambda runs inside DirectoryPathGroup.contains and DirectoryStructureGroup.createSubgroups for
every entry. If any entry in the library has a non-online link that is not a valid path on the
platform (for example ?, *, < or | on Windows), InvalidPathException propagates out of
subgroup creation and hit counting, so the folder tree fails to build or refresh for the whole
library.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[R155-159]

+                               .or(() -> entry.getFiles().stream()
+                                              .filter(linkedFile -> !linkedFile.isOnlineLink())
+                                              .findFirst()
+                                              .map(linkedFile -> Path.of(linkedFile.getLink()))
+                                              .filter(path -> !path.isAbsolute()));
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The PDF fallback in `sourceFileLookup` calls `Path.of(linkedFile.getLink())` without a guard. A link that is not a valid path throws `InvalidPathException` from group matching and subgroup creation.

## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[151-160]

## Recommended Fix
Replace the `.map(linkedFile -> Path.of(linkedFile.getLink()))` step with a helper that returns `Optional<Path>`. The helper should catch `InvalidPathException` and return `Optional.empty()`, following `LinkedFile.findIn`. Use `flatMap` to apply it. Optionally skip empty links.

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


View medium (8)
4. Bulk file changes rebuild the folder tree once per file 🐞 Bug ⭐ New
Description
Every inbound handler (insertNewEntries, handlePdfCreated, removeEntries, the move path) calls
refreshGroupsView for each single file. Each call makes refreshGroup rebuild the whole directory
subtree on the JavaFX thread, through createSubgroups over all entries and new
GroupNodeViewModels, and each new view model starts its own full match-count pass. When many files
arrive at once (copying a folder, a git checkout, extracting an archive), that work repeats once per
file, roughly files × entries × directories, which can make the UI stutter for a long time.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[R707-711]

+    /// The directory-structure group materializes its subgroups from the entries; after
+    /// structural changes the groups panel must recompute (TexGroup precedent).
+    private void refreshGroupsView() {
+        databaseContext.getMetaData().groupsBinding().invalidate();
    }
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Each inbound file event invalidates `groupsBinding`, which rebuilds the whole directory group tree on the FX thread. Bulk file operations trigger one full rebuild per file.

## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[707-711]
- jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[393-402]

## Recommended Fix
Coalesce refreshes. In the synchronizer, set a pending flag and schedule one `groupsBinding().invalidate()` after a short quiet period, or once per processed batch of watch events. Alternatively, in `refreshGroup`, skip `setAll` when the recomputed directory set equals the current one, so only real structural changes rebuild the children.

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


5. Equality check on unannotated parameter lacks @nullable 📘 Rule violation
Description
DirectoryPathGroup.equals(Object o) sits in a @NullMarked class and performs o == null on a
parameter declared as plain Object, so the null possibility is not expressed in type-use position.
Callers and tooling that rely on the JSpecify annotations will see o as non-null while the method
explicitly handles null, and a later reader cannot tell whether the check is intended.
Code

jablib/src/main/java/org/jabref/model/groups/DirectoryPathGroup.java[R48-52]

+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
In the `@NullMarked` class `DirectoryPathGroup`, `equals(Object o)` performs `o == null`, but the parameter is not annotated `@Nullable`.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/model/groups/DirectoryPathGroup.java[48-52]
## Recommended Fix
Change the signature to `public boolean equals(@Nullable Object o)` and import `org.jspecify.annotations.Nullable`, keeping the null check as is.

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


6. Directory group cannot be created from a chosen root 📎 Requirement gap
Description
The ticket-derived rule expects a user-selectable "Directory structure" group type rooted at a
chosen directory. The diff only installs a DirectoryStructureGroup automatically in
installDirectoryGroups when a directory library is scanned, and adds no creation path to the
group-type choices, so the user cannot create this group from a selected root. This looks like an
intentional replacement of that mechanism by the automatic install, so it is recommended to confirm
the rule is superseded rather than to implement the selection flow.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[R140-142]

+    private void installDirectoryGroups(BibDatabaseContext databaseContext, DirectoryLibraryCatalog catalog, Path root) {
+        Function<BibEntry, Optional<Path>> sourceFileLookup = sourceFileLookup(catalog, root);
+        GroupTreeNode groupsRoot = new GroupTreeNode(GroupsFactory.createAllEntriesGroup());
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The ticket-derived rule asks for a user-selectable "Directory structure" group type rooted at a chosen directory. The PR installs the group automatically when a directory library is opened, with no creation action in the group UI.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[136-146]
## Recommended Fix
Either document in the PR/requirements that the automatic install on Open folder as library supersedes the user-selected root flow, or add a group-type entry that creates a DirectoryStructureGroup for a selected directory.

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


7. Sidecar edits leave folder groups stale 🐞 Bug
Description
applyChangedFile inserts and removes entries from an existing sidecar without calling the new
refreshGroupsView helper. If an external edit adds the first entry in a directory or removes its
last one, the groups panel retains the old folder tree until another invalidation occurs.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[R575-578]

+        modelUpdateMarshaller.accept(() -> {
+            databaseContext.getDatabase().insertEntries(newEntries, EntriesEventSource.SHARED);
+            refreshGroupsView();
+        });
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The new group refresh covers imported sidecars but not entry additions or removals in an already-known sidecar.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[575-578]
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[580-618]
## Recommended Fix
Invalidate the groups binding after `applyChangedFile` has finished its entry and catalog updates, using the model-update marshaller so subgroup reconstruction observes the resulting state.

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


8. Folder refreshes can clear selection 🐞 Bug
Description
refreshGroup replaces the directory's complete child tree but only re-adds its own groupNode if
selected, not any selected descendant. When synchronization refreshes the tree while a nested folder
is selected, its displayed tree item is removed and the tree-selection binding can clear that
selection.
Code

jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[R395-396]

+            if (groupNode.getGroup() instanceof DirectoryStructureGroup directoryStructureGroup) {
+                children.setAll(automaticSubgroups(directoryStructureGroup));
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Rebuilding directory child view models removes selected descendants from the displayed tree without restoring their selection.
## Fix Focus Areas
- jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[385-403]
- jabgui/src/main/java/org/jabref/gui/groups/GroupTreeView.java[217-224]
## Recommended Fix
Retain matching directory nodes and their view models across refreshes, or map selected directory paths to the rebuilt nodes and restore selection before publishing the updated tree.

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


9. Adding a folder group loses the new group 🐞 Bug
Description
directoryChain creates each top-level directory node detached, so its view model reports
isRoot() even though it appears beneath the directory-structure group. The add-group control
consequently bypasses the new read-only check; adding a group attaches it only to that generated
node, which is not part of the persisted metadata tree and disappears when the directory view
rebuilds.
Code

jablib/src/main/java/org/jabref/model/groups/DirectoryStructureGroup.java[R40-41]

+    private Set<GroupTreeNode> directoryChain(Path directory) {
+        GroupTreeNode top = new GroupTreeNode(new DirectoryPathGroup(directory.subpath(0, 1), sourceFileLookup));
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Top-level generated folder nodes appear as roots to the GUI, exposing an add-group action that writes only to a disposable tree.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/model/groups/DirectoryStructureGroup.java[39-48]
- jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java[133-141]
- jabgui/src/main/java/org/jabref/gui/groups/GroupTreeView.java[288-298]
## Recommended Fix
Ensure generated directory rows cannot take the root-only add-group branch; base action eligibility on the actual displayed metadata root and the directory row's read-only capability.

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


10. Group lookups race the file synchronizer 🐞 Bug
Description
The sourceFileLookup closure installed by installDirectoryGroups reads
DirectoryLibraryCatalog, which is backed by plain HashMaps. Until now only the synchronizer
touched the catalog, under its own monitor. Now DirectoryPathGroup.contains/createSubgroups read
it from the JavaFX thread and from the background match-count tasks while the sync thread is
changing it. A concurrent register/removeFile/relocateFile, including the
remove-then-re-register window in applyChangedFile, can give a reader a missing or inconsistent
source, so the entry briefly drops out of its group or is counted under the PDF fallback.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[R151-154]

+    private static Function<BibEntry, Optional<Path>> sourceFileLookup(DirectoryLibraryCatalog catalog, Path root) {
+        Path absoluteRoot = root.toAbsolutePath();
+        return entry -> catalog.sourceOf(entry)
+                               .map(source -> absoluteRoot.relativize(source.yamlFile().toAbsolutePath()))
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The directory groups read `DirectoryLibraryCatalog` (plain HashMaps) from the UI and background threads while the synchronizer changes it on its own thread.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryCatalog.java[28-74]
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibraryScanner.java[151-160]
## Recommended Fix
Make the catalog thread-safe (synchronize its methods, or use ConcurrentHashMap and copy-on-write lists). Also make `relocateFile` and the remove/re-register in `applyChangedFile` atomic, for example with a single `replaceFile` method. Another option is to have the lookup read an immutable snapshot that the synchronizer publishes after each change.

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


11. Folder groups don't update after in-app edits 🐞 Bug
Description
refreshGroupsView is called only by inbound file-event handlers, while assignSidecar and local
removal through handleLocalRemoval/writeFile change catalog mappings without invalidating the
groups view. When write-back assigns a sidecar in a subfolder or removes a folder’s last entry, the
new subgroup remains absent or the empty subgroup persists until an unrelated external file event
refreshes the tree.
Code

jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[R707-711]

+    /// The directory-structure group materializes its subgroups from the entries; after
+    /// structural changes the groups panel must recompute (TexGroup precedent).
+    private void refreshGroupsView() {
+        databaseContext.getMetaData().groupsBinding().invalidate();
  }
Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Local write-back can change which directory contains an entry or remove a directory’s final entry, but the directory subgroup tree is only refreshed after inbound file events.
## Fix Focus Areas
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[325-365]
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[414-440]
- jablib/src/main/java/org/jabref/logic/directorylibrary/DirectoryLibrarySynchronizer.java[707-711]
## Recommended Fix
After `assignSidecar` registers a sidecar and after `writeFile` removes entries or files from the catalog, marshal a groups-view refresh with `modelUpdateMarshaller.accept(this::refreshGroupsView)`. Run it after the relevant catalog updates so the rebuilt subgroups reflect the new mappings. Alternatively, refresh directory subgroups when the database change listener sees entries added or removed.

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


Grey Divider

Tip of the day
💡 Did you know, you can reply 'qodo' on any finding to push back, ask questions, or dig deeper

More tips ↗ | Customize Qodo ↗ | Qodo docs ↗

Grey Divider

Qodo Logo

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant