What is the Neural Link?

The Neural Link is a bi-directional bridge that connects AI agents directly to the Neo.mjs runtime. It lets agents inspect the Scene Graph, component state, event listeners, computed styles, and DOM rectangles, and mutate the running application in real time.

Why is Neo.mjs called an Application Engine instead of a framework?

Neo.mjs maintains persistent application objects in a worker-backed Scene Graph instead of compiling application state away into ephemeral DOM nodes. That architecture enables multi-window orchestration, runtime permutation, and deep AI introspection.

What is Context Engineering?

Context Engineering shapes the information and tool environment around AI agents. Neo.mjs implements it through Knowledge Base, Memory Core, GitHub Workflow, and Neural Link MCP servers for frontier harnesses, plus a File System MCP server for internal Neo.ai.Agent local loops.

What is the Neo.mjs Agent OS?

The Neo.mjs Agent OS is the repository Brain: source code and services for Memory Core, Knowledge Base, Active Hybrid GraphRAG, DreamService, Golden Path synthesis, A2A coordination, and Neural Link tooling.

Frontmatter

id	8196
title	Refactor: Neural Link - Client-Side Service Architecture
state	Closed
labels	airefactoringarchitecture
assignees	tobiu
createdAt	Dec 29, 2025, 12:40 AM
updatedAt	Dec 29, 2025, 7:27 AM
githubUrl	https://github.com/neomjs/neo/issues/8196
author	tobiu
commentsCount	1
parentIssue	8169
subIssues	[]
subIssuesCompleted	0
subIssuesTotal	0
contentTrust
projected
quarantined	0
signals	[]
blockedBy	[]
blocking	[]
closedAt	Dec 29, 2025, 7:27 AM

Refactor: Neural Link - Client-Side Service Architecture

Closed v11.18.0/archive-v11-18-0-chunk-1 airefactoringarchitecture

tobiu commented on Dec 29, 2025, 12:40 AM

Context: As we add more Neural Link tools (inspect_store, get_record, query_component, etc.), the src/ai/Client.mjs file's handleRequest method is becoming a massive switch-statement monolith. This mirrors the early state of the server-side ConnectionService before we split it into domain-specific services (DataService, ComponentService, etc.).

Problem:

Maintenance Risk: A single file handling all domain logic (data, UI, navigation, inspection) is hard to read and maintain.
Scalability: Adding new tools increases the file size and complexity linearly.
Testing: Harder to unit test isolated functionality when it's all in one "god method".

Requirement: Refactor the client-side handling into a service-based architecture, similar to the server-side.

Proposed Architecture:

Neo.ai.client.Service (Base Class): Base class for client-side services.
Domain Services:
- Neo.ai.client.ComponentService: Handles query_component, get_component_tree, etc.
- Neo.ai.client.DataService: Handles inspect_store, get_record, list_stores.
- Neo.ai.client.RuntimeService: Handles reload_page, get_window_info.
Service Registry: Neo.ai.Client should delegate requests to these registered services based on the method name or a lookup map.

Goal: Ensure the client-side architecture remains clean and scalable as the Neural Link capabilities grow.

tobiu Dec 29, 2025, 7:26 AM

Input from Neo Agent OS:

◆ I have successfully refactored the Neural Link Client into a service-based architecture.

Changes:

Architecture:

Replaced the monolithic handleRequest in Neo.ai.Client with a dispatcher.

Created src/ai/client/Service.mjs as the base class.

Created domain services: ComponentService, DataService, RuntimeService.

Standards Compliance:

Enforced camelCase for all service methods (e.g., queryComponent).

Implemented Neo.snakeToCamel() in the dispatcher to map incoming JSON-RPC methods (snake_case) to internal methods.

Scalability:

New tools can now be added by extending the appropriate service without touching the main Client file.

The refactoring is verified and committed.