Anahata ASI Studio - NetBeans

Apache Licensed Enterprise Ready Donation Based Support
Designed for hihg 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 worflow. 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 optimstic 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
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.
NbJava JIT Compiler
Run, Edit, Re-Run LLM generated Java code against your project sources with Anahata's JIT Compiler
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.
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):

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.

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.

NbJava Toolkit (2 Tools)

On-The-Fly, NetBeans-aware, Swing-aware, User-editable, Java execution engine that can execute any java code directly on the NetBeans JVM without any secondary java process.

  • Default Classpath: The model can literally execute any java code using 450+ netbeans jars and the ASI platform's jars (e.g. anything you can do with NetBeans apis or creating new AGI containers).
  • Project's classpath: The model can extend the default classpath with your projects compile or test classpaths to prototype and test code on-the-fly
  • Infinity classpath: The model can download any jar on Earth and execute code against it directly on the NetBeans JVM (no restarts, no separate process).
compileAndExecuteInProject(...) Prompt

Executes model code using the project's own target/classes.

compileAndExecute(code, ...) Prompt

Inherited: Executes code in the application's JVM.

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.