how to put a little badge on files and folders in the projects view like the git plugin

[priyanahata]

Does anybody know how to put a little badge on files and folders in the projects view like the git plugin but without making a versioning system? 
I tried the StatusDecorator (seems to be more for TopComponents) and subclassing VersioningSystem (seems like nb can only choose one per project) so either way no go.
any insights?

[Chris2011]

What badge do you mean? The little blue thing that you can see that there is smth for git?

[priyanahata]

Hey @Chris2011 i juse see your message now, yes, like that beautiful git icon one
its for an ai plugin, just so i can see what files are in context
say on a plugin you are tracking a bunch of files and you wan to decorate those

[priyanahata]

also intersted in adding a little html chunk to the tooltip that shows when you hover over

[Chris2011]

Unfortunately, I dunno, whether this is possible from a 3rd-party-plugin, maybe @matthiasblaesing or @lkishalmi have an answer

[priyanahata]

There has a to pythonic way....

This is how far a gazillion tokens and i have gone with like 108 dependencies with all the possible private packages

Pretty buggy right now it seems, tends to trash the annoatation pipelin

package uno.anahata.asi.nb.context;

import java.awt.Image;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import org.netbeans.modules.masterfs.providers.AnnotationProvider;
import org.netbeans.modules.masterfs.providers.InterceptionListener;
import org.netbeans.modules.versioning.core.VersioningAnnotationProvider;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStatusEvent;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.actions.Presenter;
import org.openide.util.lookup.ServiceProvider;

@ServiceProvider(service = AnnotationProvider.class, position = 0) 
public class AnahataAnnotationProvider extends AnnotationProvider {

    private static final Logger LOG = Logger.getLogger(AnahataAnnotationProvider.class.getName());
    private static final Image BADGE;

    static {
        LOG.info("AnahataAnnotationProvider static init");
        Image original = ImageUtilities.loadImage("icons/anahata.png");
        if (original != null) {
            BADGE = original.getScaledInstance(8, 8, Image.SCALE_SMOOTH);
        } else {
            BADGE = null;
        }
    }

    @Override
    public Image annotateIcon(Image icon, int type, Set<? extends FileObject> files) {
        LOG.log(Level.INFO, "AnahataAnnotationProvider.annotateIcon called for files size: {0}", files.size());
        
        // Start with the original icon, allowing other providers to annotate first
        icon = VersioningAnnotationProvider.getDefault().annotateIcon(icon, type, files);
        
        // Add our badge if needed
        for (FileObject fo : files) {
            /*
            if (FakeContext.contains(FileUtil.toFile(fo))) {
                LOG.log(Level.INFO, "AnahataFileAnnotator: Annotating icon for: {0}", fo.getName());
                if (BADGE != null) {
                    // Use top-right (8, 0) to avoid Git's bottom-right badges
                    return ImageUtilities.mergeImages(icon, BADGE, 16, 0);
                }
            }*/
        }
        return icon; 
    }

    @Override
    public String annotateName(String name, Set<? extends FileObject> files) {
        LOG.log(Level.INFO, "AnahataFileAnnotator.annotateName called for name: {0}", name);
        
        // Start with the original name, allowing other providers to annotate first
        //String name = VersioningAnnotationProvider.getDefault().annotateNameHtml(name, files);
        
        for (FileObject fo : files) {
            /*
            if (FakeContext.contains(FileUtil.toFile(fo))) {
                LOG.log(Level.INFO, "AnahataFileAnnotator: Annotating name for: {0}", fo.getName());
                return name + " [IC]";
            }*/
        }
        return name;
    }

    @Override
    public String annotateNameHtml(String name, Set<? extends FileObject> files) {
        LOG.log(Level.INFO,"AnahataFileAnnotator.annotateNameHtml called for name: {0} files {1}", new Object[]{name, files});
        
        // Start with the original name, allowing other providers to annotate first
        String annotated = VersioningAnnotationProvider.getDefault().annotateNameHtml(name, files);
        
        for (FileObject fo : files) {
            /*
            if (FakeContext.contains(FileUtil.toFile(fo))) {
                String label = " <font color='#008000'>[IC]</font>";
                if (annotated.toLowerCase().contains("<html>")) {
                    if (annotated.toLowerCase().endsWith("</html>")) {
                        return annotated.substring(0, annotated.length() - 7) + label + "</html>";
                    }
                    return annotated + label;
                }
                return "<html>" + annotated + label + "</html>";
            }*/
        }
        return annotated;
    }


    @Override
    public Action[] actions(Set<? extends FileObject> files) {
        LOG.info("------------------actions()----------------------------: " + files);
        List<Action> actions = new ArrayList<>();
        actions.add(new AnahataSubmenuAction(files));
        return actions.toArray(Action[]::new);
    }

    
    @Override
    public Lookup findExtrasFor(Set<? extends FileObject> files) {
        LOG.log(Level.INFO, "AnahataFileAnnotator.findExtrasFor called for files size: {0}", files);
        return super.findExtrasFor(files);
    }
     

    
    @Override
    public InterceptionListener getInterceptionListener() {
        LOG.info("AnahataFileAnnotator.getInterceptionListener called");
        return new InterceptionListener() {

            @Override
            public void beforeDelete(FileObject fo) {
                LOG.info("About to delete: " + fo.getPath());
            }

            @Override
            public void deleteSuccess(FileObject fo) {
                LOG.info("Successfully deleted: " + fo.getPath());
            }

            @Override
            public void deleteFailure(FileObject fo) {
                LOG.warning("Failed to delete: " + fo.getPath());
            }

            @Override public void beforeCreate(FileObject parent, String name, boolean isFolder) {}
            @Override public void createSuccess(FileObject fo) {}
            @Override public void createFailure(FileObject parent, String name, boolean isFolder) {}
        };
    }

    public class AnahataSubmenuAction extends AbstractAction implements Presenter.Popup {

        private Set<? extends FileObject> files;

        public AnahataSubmenuAction(Set<? extends FileObject> files) {
            super("AnahataSubmenuAction", new ImageIcon("icons/anahata.png"));
            this.files = files;
        }

        @Override
        public void actionPerformed(ActionEvent e) {}

        @Override
        public JMenuItem getPopupPresenter() {
            JMenu submenu = new JMenu("Anahata");
            submenu.setIcon(new ImageIcon("icons/anahata.png"));
            
            submenu.add(new JMenuItem(new AbstractAction("Add To Context", submenu.getIcon()) {
                @Override
                public void actionPerformed(ActionEvent e) {
                    LOG.info("Adding: " + files);
                    //FakeContext.addFileObjects(files);
                    try {
                        FileSystem fs = files.iterator().next().getFileSystem();
                        LOG.info("Firing event on file system : " + fs);
                        AnahataAnnotationProvider.this.fireFileStatusChanged(new FileStatusEvent(fs, files, true, true));
                    } catch (Exception ex) {
                        LOG.log(Level.SEVERE, "Exception adding files to fake context ", ex);
                    }
                    
                }
            }));

            submenu.add(new JMenuItem(new AbstractAction("Remove From Context") {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // TODO: Implement removal
                }
            }));

            return submenu;
        }
    }

}

[Chris2011]

If not done yet, you can have a look into the VCS integration hoe NB core does it, but I guess you already did? If yes, what about adding this into the core or making changes to the core, so that your plugin will work for further stuff, unfortunately starting for next NB release after releasing it.

[priyanahata]

Hey @Chris2011 I am still getting there, yes, been digging into the VCS Integration and done some progress in annotating projects in context and files in context and all that putting a little badge above the git icon but very flaxy still and "crashing" with the error badges.

I also still need to "master" the LocalHistory so when the LLM makes change to a file, we can see it there in the Local History

How do i add it to the core? Currently I have like 9 "impl" things in moduleDependencies and like 40 netbeans deps in the normal section

Yesterday we did a massive improvement in regards of reporting compiler alerts to the model. It is super fast now.

Working super hard on v2 Chris. Check it out

[Chris2011]

Awesome, you are doint a great job

[priyanahata]

@Chris2011 We are super bored on our discord channel https://discord.gg/hRReaPuA drop by, say hi, ask for a feature

[priyanahata]

@Chris2011 Without your cheering up, things would be much harder, when is 29 coming out? have you got a rought idea? ive seen the RC announced on the mailing list

[Chris2011]

Yes RC is out, so it will be not that late to the party. I dunno it exactly but soon.

[Chris2011]

I've not used it, I will, atm I need to check what the UI means. I'm more or less hyped by the AI integrations into vs code like claude code or the AI stuff in intellij. Cleaner is better IMHO. But just let this discuss in discord, also after I tired it, not here. This is not the right way here, due to your original question.

[priyanahata]

what the UI means? what does that mean?

[priyanahata]

but does VsCode run LLM generated java code on vscode?

[priyanahata]

@Chris2011 does VsCode or IntelliJ run LLM generated java code on vscode?

[Chris2011]

Please focus, as I said, this is not the right chanel here. thx.