Anahata ASI Studio - NetBeans

See in Plugin Portal
Apache Licensed Enterprise Ready Donation Based Support
Designed for high level Enterprise Architecture, Engineering & Review, not typing assistance. High-fidelity awareness of all types, hierarchies and members across all open projects leveraging NetBeans syntax trees, code analysis, diagnostics, editor hints, refactoring and versioning APIs. Mermaid UML support.
Fully reviewable, editable changes to multiple source code files with cherry-picking and overlaid comic-style bubbles for AI comments directly in the NetBeans-native Diff Viewer (Graphical side-by-side or textual). One-Shot fetching of any project, dependency or JDK sources. Add remote URIs to context.
True self-correcting agentic workflow. When the model creates, deletes or modifies a source file, Anahata holds the reloop until the netbeans source code scanner finishes and reports any compiler errors, warnings or project problems during reloop. No need to build. If you see an error badge, so will the model. Built-in optimistic locking protection.
Real-time visual context awareness — files light up in the Projects, Files or Favourites view the moment the agent or you loads them onto context. Support for multiple active sessions. See which files are in context like you see which files have git changes.
JIT compilation and execution of LLM generated java code against project sources, dependencies, netbeans apis or any Java library on the internet directly on the NetBeans JVM with Anahata's custom Child-First Classloader. Use your project's classpath or any other.

Anahata ASI Container Reference Implementation and SDK for developing custom Anahata ASI Containers

Stateful, Persistent, Multimodal, Annotation driven AGI Toolkits with built-in EJB/Servlet style context propagation and prompt augmentation. Request / Session / Application attribute Maps. Lifecycle Management. Hierarchical Context Providers.
Fully Autonomous, Fully Observable, Fully Auditable JVM Agent with per-tool security. Flight Recorder, Autobackups. Editable, reviewable, re-runnable tool calls.
CwGC - Two-stage Context Window Garbage Collector with configurable, fine grained, depth based reclamation: per part type, toolkit or tool. Both model and user can Prune (Soft delete) / Unprune or Pin any item in the history, check the Garbage Collection Logs for infinitely running sessions.
Custom ResourceHandle (NbHandle) to treat FileObjects like any other Anahata ASI resource. Custom ResourceUI for netbeans syntax highlighting, open in editor, select in projects. Custom ParameterRenderers for netbeans native diff viewer. Custom Context Window Event Listeners to highlight resources in context in the NetBeans
NbJava JIT Compiler
Run, Edit, Re-Run LLM generated Java code against your project sources with Anahata's JIT Compiler
Live Screen Sharing
Live Screen Sharing - Share your screen, individual monitors, or custom regions with the ASI for multimodal visual feedback.
In-Context Resource Visualization
Real-time visual context awareness — files light up in the Projects view the moment the agent loads them or you add them to context.
High-Fidelity 3D Prototyping
High-Fidelity 3D Prototyping - Bundled LWJGL & OpenGL support for raw, real-time 3D engineering directly on the JVM.
Inline AI Annotations
Agentic Feedback - Real-time inlined AI explanations overlayed over intended changes.
Custom FileObject Resource Adapter
Custom FileObject Resource adapter for synching file changes to resources in context
Project Structure
Directory Tree for all Project Source Groups with element kinds, inner types, versioning info and file sizes.
Project Alerts
Instant Diagnostics - Monitoring compiler errors and project health via context providers.
Radio Toolkit
Focused Development - The integrated Radio toolkit providing the soundtrack for Tiki-Taka coding.
Context Window GC
Metabolic Intelligence - Real-time tracking of the context window garbage collector.
Editable Tool Calls
Human-in-the-Loop - Edit tool parameters and Java payloads with syntax highlighting before execution.
Tool Permissions
Security First - Manage granular Prompt, Always, or Never permissions for 148 tools.
AI Provider Preferences
Universal Hub - Configure multiple models and API keys to prevent vendor lock-in.
Natural Language control of NetBeans - Open and close projects, open and close files, clean, build, shut down, select in projects, files or favourites, hundreds of NetBeans APIs available to the model.
NetBeans Problem Provider, Compiler Alerts and Hint Integration - Automatic, On-the-turn compiler alerts. If you see an error badge the model will get the detailed compile error, project warnings or problems. Fetch and fix editor hints like 'remove unused imports' across all files and projects.
NetBeans Maven index integration - Ultra fast artifact search across all public or private maven repositories listed in settings.xml
Unified Resource Management - Multimodal Local And Remote Resources, Custom NbHandle for FileObject integration - Ctrol + O tools for the model to "Single-Shot" fetch any dependency sources.
Autobackups - Context Window Flight Recorder - Fully Auditable Agentic Execution - Persists the AgiContainer on every turn and after each executed tool.

It contains all the tools of the standalone version, plus these toolkits (the ones that are only available in NetBeans):

The Anahata ASI Flywheel (Singularity Loop)

The core strategic advantage of Anahata ASI Studio is the Anahata ASI Flywheel—the ultimate, self-sustaining loop of agentic software engineering. Rather than treating code generation as a stateless text-completion task, Anahata orchestrates a continuous cycle of perception, action, and validation directly within the NetBeans compiler.

1. Perception (CodeModel & Projects): The ASI reads the exact Abstract Syntax Tree (AST) and project hierarchy. It understands your Maven dependencies, Java versions, and module structures.
2. Action (BatchCodeRefiner): The ASI executes surgical, AST-guided modifications using the V4 Text Replacement Engine. It preserves your exact indentation, blank lines, and inline comments without corrupting the surrounding code.
3. Validation (Project Alerts): The NetBeans background parser scans the modified file immediately. If the AI introduces a compilation error or missing dependency, the ProjectAlertsContextProvider instantly flags the red error badges in the very next turn's RAG message.
4. Execution (NbJava): The ASI compiles and runs the validated logic dynamically inside the NetBeans JVM using the project's own target/classes. The Singularity is achieved as the agent tests its own code in real-time.

Anahata vs. The 2026 IDE Giants

While legacy AI assistants act as surface-level text-completion engines or stateless REST API wrappers, Anahata ASI Studio is a Stateful ASI Container. It doesn't just read your code; it resides inside your JVM, manages its own context metabolism, and executes programmatic refactoring with AST-guided precision.

Capability Dimension Anahata ASI Studio IntelliJ AI Assistant

NbJava Toolkit (2 Tools)

An On-The-Fly, NetBeans-aware, Swing-aware, User-editable Java compilation and execution engine. This toolkit is the ultimate self-evolution driver, allowing the model to execute raw Java code directly inside the running NetBeans JVM without any external process overhead.

  • The Singularity Engine: Executes model-generated class files against NetBeans Platform APIs, the active workspace, and any loaded Java libraries.
  • Hot-Reload Context: Prioritizes target/classes directories, letting the model test, edit, and re-run its own Java code in real-time.
compileAndExecuteInProject(code, path, incDeps, ...) Prompt

Executes code by prepending the project's compiled build output to the classpath.

compileAndExecute(code, extraCp, options) Prompt

Compiles and runs a transient public class on the host NetBeans JVM.

BatchCodeRefiner Toolkit (1 Tool)

Advanced structural Java refinement utilizing the V4 AST-Guided Batch Mode. This is Anahata's flagship tool for executing atomized code patches across classes, methods, fields, and constructors, ensuring zero formatting drift and complete comment preservation.

  • Atomicity Guaranteed: Receives a list of multiple code refinement intents (inserts, updates, deletes, moves) and applies them programmatically in a single, safe transaction.
  • 100% Indentation Fidelity: The refiner automatically computes the target scope's indentation level, aligning your block statements without needing leading pad spaces.
refine(CodeRefinementBatch batch) Prompt

Executes a batch of AST-guided structural edits on a single Java source file.

Refactor Toolkit (17 Tools)

Transactional refactoring tools that maintain integrity across the entire project graph by leveraging the industry-standard NetBeans Refactoring engine.

  • Cross-Project Integrity: Rename members or relocate types with automatic import correction across the whole workspace.
  • Surgical Safety: Use safeDelete to verify usages before any code removal, preventing broken builds.
  • Architectural Evolution: Extract interfaces, pull up members to superclasses, or invert boolean logic via natural language.
rename(path, newName) Prompt

Safe rename updating all references in the workspace.

renameMember(path, member, newName) Prompt

Renames a class member across all open projects.

move(path, targetFolder) Prompt

Relocates types or files while correcting imports.

copy(path, targetFolder) Prompt

Copies a file or class to a different package.

safeDelete(path, comments) Prompt

Verifies usages before removing elements.

inline(path, member, type) Prompt

Replaces usages with method body or constant value.

encapsulateField(path, field, g, s) Prompt

Creates getter/setter and updates all references.

invertBoolean(path, member, newName) Prompt

Inverts logic and updates all call sites.

extractInterface(path, name, members) Prompt

Moves members to a new interface.

pullUp(path, target, members) Prompt

Moves members to a superclass.

pushDown(path, members) Prompt

Moves members to subclasses.

changeMethodSignature(...) Prompt

Updates name, return type, and parameters.

extractSuperclass(path, name, members) Prompt

Extracts a new superclass from existing class.

useSupertype(path, supertypeFqn) Prompt

Replaces class usages with a supertype.

moveInnerToTopLevel(path, name) Prompt

Promotes a nested class to its own file.

whereUsed(path, comments) Always

Finds all references of a file or type.

whereUsedMember(path, member, comm) Always

Finds all usages of a specific class member.

CodeRefiner Toolkit (8 Tools)

Advanced structural Java code manipulation that operates directly on the NetBeans Abstract Syntax Tree (AST) rather than simple text buffers. This ensures 100% semantic integrity during code evolution.

  • Direct AST Transformation: CodeRefiner treats your Java code as physical semantic nodes, rewriting signatures and doc trees while preserving leading and trailing formatting.
  • Integrated Import Management: Updates automatically trigger an import optimization pass, converting FQNs to simple imports without compile namespace leaks.
insertMember(path, class, decl, body, ...) Prompt

Structurally inserts a new method, field, or inner class.

updateMember(path, fqn, decl, body, ...) Prompt

Surgically updates member signature, body, or javadoc.

setJavadoc(path, fqn, javadoc) Prompt

High-fidelity documentation update using AST Rewriting.

deleteMember(path, fqn, optimize) Prompt

Removes a member while maintaining structural integrity.

moveMember(path, fqn, pos, anchor) Prompt

Relocates members within a class using AST pointers.

optimizeImports(path, removeUnused) Prompt

FQN-to-simple-name conversion and unused removal.

addImports(path, imports) Prompt

Explicitly adds multiple FQNs to the import section.

reformat(path, save) Prompt

Applies IDE code style rules to the entire file.

CodeModel Toolkit (16 Tools)

Powered by the NetBeans Java Index, enabling high-performance type exploration and one-shot FQN resolution.

  • Ctrl+O Mastery: The model uses the same binary index as the IDE to find types across the entire project graph instantly.
  • Hierarchy Exploration: Recursively build implementation and inheritance trees for any type in the classpath.
  • Dependency Inspecter: Fetch source code and Javadoc for project dependencies in a single shot without manual navigation.
findTypes(query, ...) Always

Index-based search across all projects (Ctrl+O).

loadTypeSources(javaType) Always

Registers a type's source file as a resource.

loadTypeSourcesByFqn(fqn) Always

One-shot source loading for known FQNs.

getTypeJavadocs(javaType) Always

Retrieves the Javadoc for a given type.

getTypeJavadocsByFqn(fqn) Always

Javadoc retrieval for known FQNs.

getMemberSources(member) Always

Retrieves source code for a specific member.

getMemberSourcesByFqn(fqn) Always

Source loading for known member FQNs.

getMemberJavadocs(member) Always

Retrieves Javadoc for a specific member.

getMemberJavadocsByFqn(fqn) Always

Javadoc retrieval for known member FQNs.

getMembers(javaType, ...) Always

Lists fields, constructors, and methods.

getMembersByFqn(fqn, ...) Always

Jump straight to members of a known type.

findTypesInPackage(...) Always

Scans a package (optionally recursive) for types.

getSubtypes(javaType, depth) Always

Explores implementations for a JavaType.

getSubtypesByFqn(fqn, depth) Always

Builds recursive implementation trees.

getSupertypes(javaType, depth) Always

Explores inheritance for a JavaType.

getSupertypesByFqn(fqn, depth) Always

Builds recursive inheritance trees.

Maven Toolkit (7 Tools)

Leverages the host IDE's internal Maven engine for synchronous build goal execution and recursive dependency resolution.

  • Native Execution: Runs clean, install, or prime goals using the NetBeans Maven embedder.
  • Transitive Awareness: The model fetches the full runtime classpath, including all hidden transitive dependencies.
  • Fast Artifact Search: Connects to the local and central Maven indexes for ultra-fast GAV coordinate discovery.
runGoals(projectId, goals, ...) Prompt

Executes Maven goals (clean, install) synchronously.

addDependency(path, g, a, v, ...) Prompt

Surgically adds a dependency to the project POM.

getDeclaredDependencies(path) Always

Lists dependencies directly declared in the POM.

getResolvedDependencies(path) Always

Returns the full transitive runtime classpath.

searchMavenIndex(query, ...) Always

Searches Central and local repositories for artifacts.

downloadProjectDependencies(...) Always

Bulk downloads sources and javadocs.

downloadDependencyArtifact(...) Always

Verifies artifact existence before POM modification.

Projects Toolkit (7 Tools)

Provides the ASI with deep structural awareness of the IDE workspace and project metadata.

  • Lifecycle Control: Programmatically open/close projects or set the Main Project via natural language.
  • Multi-Module Strategy: Open all subprojects of a parent POM in a single tool call.
  • Config Management: Toggle "Compile on Save" overrides directly in nb-configuration.xml.
openProject(path, subprojects) Prompt

Opens a project in the IDE workspace.

setMainProject(path) Always

Sets the authoritative main project for the IDE.

closeProjects(paths) Prompt

Closes one or more open projects.

openSubprojects(path) Prompt

Opens all child modules of a Maven parent.

setCompileOnSaveOverride(p, bool) Prompt

Configures CoS in nb-configuration.xml.

setProjectProviderEnabled(...) Always

Toggles project-level context providers.

invokeAction(path, action) Prompt

Triggers native NetBeans project actions.

Hints Toolkit (3 Tools)

Programmatic access to the NetBeans Hint engine for automated code quality and surgical fixes.

  • Global Quality Monitor: Retrieve all warnings, performance suggestions, and potential bugs for a project.
  • Automated Cleanup: Surgically remove unused imports or fix naming conventions across multiple files.
  • AI Surgical Patching: The model applies NetBeans "Quick Fixes" directly to the source code without user intervention.
getAllHints(projectPath, ...) Always

Retrieves all warnings and suggestions for a project.

applyHintFix(filePath, hintId) Prompt

Executes the suggested quick-fix for a specific hint.

removeUnusedImports(filePath) Prompt

Surgically cleans up Java import statements.

Editor Toolkit (3 Tools)

Direct interaction with the active NetBeans editor tabs and document buffers.

  • Visual Synchronization: The model can open a file and scroll to a specific line to "show" you its thought process.
  • Workspace Observability: Knows which files you are looking at and their current modification status.
openFile(path, scrollToLine) Always

Opens and focuses a file in the IDE editor.

getOpenFiles() Always

Lists all currently open editor tabs and status.

closeAllFiles() Prompt

Clears the editor workspace.

IDE Toolkit (4 Tools)

Generic IDE orchestration, observability, and navigation tools.

  • Deep Navigation: Select and highlight elements in the Projects, Files, or Favorites tabs via the model.
  • Log Monitoring: Tails messages.log to help the model debug IDE internal issues or plugin failures.
  • Visual Layout Awareness: Reports on the state of all docked windows and TopComponents.
monitorLogs(pattern, tail) Always

Tails the IDE messages.log for real-time debugging.

selectIn(path, target) Always

Highlights elements in Projects, Files, or Favorites.

getTopComponentsMarkdown() Always

Returns a table of all open IDE windows.

getOutputTabsMarkdown() Always

Captures a snapshot of all active Output windows.

Context Providers

The sensory array of the ASI. These providers feed the RAG message with high-salience, real-time IDE metadata.

Project Overview

Injects authoritative metadata, available actions, declared dependencies, and automatically synchronizes project-specific instructions from anahata.md.

Project Structure

Provides a unified, architecturally-aware view of the project, including logical Java packages, physical resources, versioning info, and inner class hierarchies.

Project Files

Renders a real-time Markdown tree of the entire project directory, distinguishing between root files and source groups for precise surgical targeting.

Project Alerts

Continuous monitoring of Java compiler errors and project health, providing the ASI with metabolic awareness of broken code and workspace problems.

Open Windows

Observability into the user's visual workspace, reporting on all active editor tabs, explorer views, and docked TopComponents.

Output Monitor

Streaming build logs and process output from all active tabs in the NetBeans Output Window, enabling real-time debugging and feedback loops.

Universal Platform Capability Matrix

Anahata ASI NetBeans inherits the entire robust capability catalog from the ASI Desktop container. Below is the complete platform index of all 148 tools actively compiled within the current running JVM, grouped by package namespace.

Category Toolkit ID Tools Scope & Key Capabilities
Core Container AsiContainer 4 Active session pool creation, metadata inspection, and binary history dump.
Session 6 Summary dashboards, session nickname, context provider state toggles, and hosted tools.
History 4 Sliding context window desaturation, part/message soft pruning, and thumbtack pinning.
Core OS & Hardware Resources 8 URI-centric file, URL, and String handle viewport managers with optimistic locking.
Audio 4 Autonomous hardware line selection, WAV recording, and real-time RMS metering.
Screens 6 Screen and window capture, multi-monitor visual visionary, and live sharing region.
Shell 1 Host terminal interaction, process execution, and synchronous output capture.
Host 2 Active OS processes exploration, CPU diagnostics, and process termination by PID.
Speech 1 OS-independent TTS alerts and eyes-free speech synthesis.
Yam Extensions (Beta) Chrome / Firefox 38 Chromium and Gecko-based Selenium browser automation, form filling, and visual analysis.
Radio 3 Curated internet radio streaming with SomaFM API, KEXP and FIP Paris channels.