Neon3 AI Authoring MCP

Enseña a una IA a constr bien las interfaces de Ne-on3, y luego deja que Ne-on3 verifique el resultado.

[

Un servidor MCP, una Skill detallada de autoría y un kit de initído para Python/Node de Neon3. Consta de tres capas:

Skill                 durable NUI Flow rules and design boundaries
MCP resources/tools   searchable references, live capability discovery, orchestration
Neon3 runtime         authoritative parser, compiler, revision, and renderer feedback

El MCP never invierta un segundo lenguaje de UI. neon3_nui_validate invoca al compilador/parser de producción ne-on-ui-runtimime, mi entras que las mutaciones en directo utilizan el contrato neon3.rpc ya existente con prefijo de longitud.

Aspectos destacados

Requisitos

• Node.js 20 o superior.

• Ne-on3 clonado en D:\Ne-on3 en Windows, o NEON3_ROOT ajustado a otra checkout.

• Compilación la sonda de autoría de Ne-on3 una vez:

cd D:\Neon3
cargo build -p neon-ui-runtime --bin neon3_authoring_probe

The probe is the bridge between the MCP package and the exact Neon3 checkout. It returns structured JSONL and uses the same parser/compiler as the running UI runtime.

Installar desde el códifo fuente

git clone https://github.com/unco999/neon3-ai-authoring-mcp.git
cd neon3-ai-authoring-mcp
npm install
npm link

The command now is available as ne-on3-mcp.

Instalar desde npm

When published:

npm install -g @neon3/ai-authoring-mcp
neon3-mcp

For a pinned local install:

npm install --save-dev @neon3/ai-authoring-mcp
npx neon3-mcp

OpenCode Configuration

Añade una entrada MCP en la configuación de OpenCode:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neon3": {
      "type": "local",
      "command": ["neon3-mcp"],
      "enabled": true,
      "environment": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102",
        "NEON3_WGPU_ENDPOINT": "127.0.0.1:39103",
        "NEON3_PROJECTD_ENDPOINT": "127.0.0.1:39104"
      }
    }
  }
}

Copia skill/SKILL.md en el directorio de skills del host, o añade esta repo como fuente de skills. The Skill is a separate from the MCP server so that its authoring rules remain available when Neon3 is offline.

The MCP also exposes the same material as content:

neon3://skill
neon3://references/overview
neon3://references/grammar
neon3://references/components
neon3://references/statecharts
neon3://references/interactions
neon3://references/diagnostics

Claude Desktop / MCP Clients

{
  "mcpServers": {
    "neon3": {
      "command": "neon3-mcp",
      "env": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102"
      }
    }
  }
}

Planning aids

In this section table:

The Authoring Loop

reference -> capabilities -> generate NUI -> validate -> inspect -> submit -> diagnose

Example of valid, typed and semantic NUI:

version 1
surface surface.example revision 1
budget nodes=32 bindings=16 instances=16 text=16 glyphs=1024 events=8 clips=64
input title text default text:empty
input can_save bool default false
surface root column w 520 h 240 gap 8 pad 16
  text heading value $title
  button save value "Save" enabled $can_save event document.save

The NUI Flow must not contain fetch, callbacks, Python code, file paths, coordinates, GPU handles, or arbitrary expressions.

Templates

The templates/python-app and templates/node-app include:

• ne-on3.app.json application metadata

• ui/main.nui typed declarative UI

• a minimal RPC client with prefix length

• a deterministic protocol test or syntax verification

The ne-on3_app_init tool only writes below NEON3_APP_ROOT (or the current working directory if that variable is not set).

Validate NUI Without a Runtime Components

All scriptable calls implicit functioning. Do not use a live runtime though:

$source = [string]::Join("`n", (Get-Content .\templates\node-app\ui\main.nui))
$request = @{ request_id = "manual-1"; operation = "validate"; sequence = 1; source = $source } | ConvertTo-Json -Compress
$request | cargo run --quiet -p neon-ui-runtime --manifest-path D:\Neon3\Cargo.toml --bin neon3_authoring_probe

The process emits JSONL. A parser or compiler failure returns exit code 1 and includes stable diagnostics and source ranges.

Start Neon3 Headless Services

Use the existing Neon3 launcher. The MCP does not silently spawn a second renderer:

cd D:\Neon3
scripts\run-neon-services.ps1

Then call neon3_capabilities, neon3_ui_snapshot or neon3_nui_submit from the AI.

Configuration

All live endpoints should be loopback endpoints. The MCP does not expose an arbitrary shell tool.

Troubleshooting

The authoring probe cannot start

cd D:\Neon3
cargo build -p neon-ui-runtime --bin neon3_authoring_probe
$env:NEON3_ROOT = 'D:\Neon3'

revision_conflict

Call neon3_ui_snapshot, use the returned revision and submit again. You should not blindly retry a stale mutation.

Another service is unreachable

Check the endpoint in neon3_capabilities. Start Neon3 using scripts\run-neon-services.ps1 or neon-dev in a windowed configuration.

Debugging

npm install
npm test
node --check src/index.js
npm pack --dry-run

The set of test uses a deterministic local fake Neon3 endpoint and validates request IDs, integer parsing, and structured JSONL output. The actual NUI boundary is tested by the neon3_authoring_probe implementation from the Neon3 repository.

Roadmap

This repo is the AI integration layer. Neon3 remains the owner of the protocol, NUI grammar, UI runtime, WGPU runtime, and project authority:

• MCP: https://github.com/unco999/neon3-ai-authoring-mcp

• Neon3: https://github.com/unco999/Neon3-CiJian

License

MIT. See LICENSE.# Neon3 AI Authoring MCP

Enseña a una IA a construir las interfaces de Neon3 correctamente, y deja que Neon3 verifique el resultado.

Un servidor MCP, una Skill de autoría detallada y un kit de inicio para Python/Node de Neon3. Combina tres capas:

Skill                 durable NUI Flow rules and design boundaries
MCP resources/tools   searchable references, live capability discovery, orchestration
Neon3 runtime         authoritative parser, compiler, revision, and renderer feedback

El MCP nunca inventa un segundo lenguaje de UI. neon3_nui_validate invoca al analizador/compilador de producción neon-ui-runtime, mientras que las mutaciones en vivo utilizan el contrato existente neon3.rpc con prefijo de longitud.

Aspectos destacados

Requisitos

• Node.js 20 o superior.

• Neon3 clonado en D:\Neon3 en Windows, o NEON3_ROOT configurado para otra copia del repositorio.

• Compila una vez la probe de autoría de Neon3:

cd D:\Neon3
cargo build -p neon-ui-runtime --bin neon3_authoring_probe

La sonda es el puente de compatibilidad entre este paquete MCP y el checkout exacto de Neon3. Devuelve JSONL estructurado y usa el mismo analisador/compilador que el runtime de UI en ejecución.

Instaación desde el códigigo fuent

git clone https://github.com/unco999/neon3-ai-authoring-mcp.git
cd neon3-ai-authoring-mcp
npm install
npm link

El comando ahora está disponible como neon3-mcp.

Instalación desde npm

Una vez publado:

npm install -g @neon3/ai-authoring-mcp
neon3-mcp

Para una installación local con vversión fijada:

npm install --save-dev @neon3/ai-authoring-mcp
npx neon3-mcp

Configuración de OpenCode

Añade una entrado MCP en la configuación de OpenCode:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neon3": {
      "type": "local",
      "command": ["neon3-mcp"],
      "enabled": true,
      "environment": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102",
        "NEON3_WGPU_ENDPOINT": "127.0.0.1:39103",
        "NEON3_PROJECTD_ENDPOINT": "127.0.0.1:39104"
      }
    }
  }
}

Copía skill/SKILL.md en el directório de skills del host, o añade este repositorio como fuente de skills. La Skill está separado del servidor MCP para que sus directrces de autoría permanzcan disponibles cuando Neon3 está fuera de línea.

El MCP tambiende expone el esto mismo material como recursos:

neon3://skill
neon3://references/overview
neon3://references/grammar
neon3://references/components
neon3://references/statecharts
neon3://references/interactions
neon3://references/diagnostics

Neon3 / Client MCP

{
  "mcpServers": {
    "neon3": {
      "command": "neon3-mcp",
      "env": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102"
      }
    }
  }
}

Herramientas

El bucle de autoría

reference -> capabilities -> generate NUI -> validate -> inspect -> submit -> diagnose

Ejemplo de NUI válido, tjpedo y semántico:

version 1
surface surface.example revision 1
budget nodes=32 bindings=16 instances=16 text=16 glyphs=1024 events=8 clips=64
input title text default text:empty
input can_save bool default false
surface root column w 520 h 240 gap 8 pad 16
  text heading value $title
  button save value "Save" enabled $can_save event document.save

NUI Fluent not de contener fetch, callbacks, código Python, rutas de ar, coordenadas, webGPU handles, o expressions rudim redundant.

Plantillas

templates/python-app y templates/node-app incluyen:

• metadata de app neon3.app.json

• interui declarativa tipada ui/main.nui

• un client RPC mínimo con prefjo de longitud

• una verificación determinista de protocol o test de sintaxis

La herramienta neon3_app_init solo escribe debajo de NEON3_APP_ROOT (o en el working directory cuando no se ha definido el parámetro).

Validar NUI sin Runtime or Runtime Activo

$source = [string]::Join("`n", (Get-Content .\templates\node-app\ui\main.nui))
$request = @{ request_id = "manual-1"; operation = "validate"; sequence = 1; source = $source } | ConvertTo-Json -Compress
$request | cargo run --quiet -p neon-ui-runtime --manifest-path D:\Neon3\Cargo.toml --bin neon3_authoring_probe

El proceso emite JSONL. Un error de parser o compilado devuelve el exit code 1 e include diagnóstico estables y fragmentos origins.

Iniciar Neon3 Headless tencias

Use launcher existente de Neon3. La herramienta MCP no llama a un segundo renderer:

cd D:\Neon3
scripts\run-neon-services.ps1

Después, ejecute neon3_capabilities, neon3_ui_snapshot, o neon3_nui_submit desde el client IA.

Configuración

All endpoints live must be loopback endpoints. The MCP does not provide an arbitrary shell tool.

Troubleshooting

The authoring probe cannot start

GXP{3

revision_conflict

Call neon3_ui_snapshot, use the returned authoritative revision, and submit again. Do not blindly retry a stale mutation.

El service is not accesible

Check the endpoint neon3_capabilities. Start the Neon services with scripts\run-neon-services.ps1 o yes use neon-dev for a basic window case.

Develop

npm install
npm test
node --check src/index.js
npm pack --dry-run

The test protocol uses a deterministic fake local Neon3 endpoint and checks request IDs, framing, and structured JSONL output. The real NUI boundary is verified by neon3_authoring_probe in the Neon3 repository.

Project Relationship

This repo is the AI integration layer. Neon remains the owner of the protocol, NUI grammar, runtime, WGPU runtime, and project authority:

• MCP: https://github.com/unco999/neon3-ai-authoring-mcp

• Neon3: https://github.com/unco999/Neon3-CiJian

License

MIT. See LICENSE.# Neon3 AI Authoring MCP

Enseña a una IA a construir interfaces de Neon3 correctamente, y luego deja que Neon3 valide el resultado.

Un servidor MCP, una Skill de autoría detallada y un kit de inicio para Python/Node de Neon3. Combina tres capas:

Skill                 durable NUI Flow rules and design boundaries
MCP resources/tools   searchable references, live capability discovery, orchestration
Neon3 runtime         authoritative parser, compiler, revision, and renderer feedback

El MCP nunca inventa un segundo lenguaje de UI. neon3_nui_validate invoca al analizador/compilador de producción neon-ui-runtime, mientras que las mutaciones en directo utilizan el contrato existente neon3.rpc con prefijo de longitud.

Aspectos destacados

Seguridad son expuestas.

Requisitos

• Node.js 20 o unha.

• Neon3 clonado en D:\Neon3 en Windows, o NEON3_ROOT configurado para otro checkout.

• Construye una vez la sonda de autoría de Neon3:

cd D:\Neon3
cargo build -p neon-ui-runtime --bin neon3_authoring_probe

La sonda es el puente de compatibilidad entre este paquete MCP y el checkout exacto de Neon3. Devuelve JSONL estructurado y usa el mismo analizador/compilador que el runtime en ejecución.

Instalar desde el código fuente

git clone https://github.com/unco999/neon3-ai-authoring-mcp.git
cd neon3-ai-authoring-mcp
npm install
npm link

Si quieres instalar el comando ahora como neon3-mcp.

Instalar desde npm

Cuando esté publicado:

npm install -g @neon3/ai-authoring-mcp
neon3-mcp

Para una instalación local fija:

npm install --save-dev @neon3/ai-authoring-mcp
npx neon3-mcp

Configuración de OpenCode

Añade una entrada MCP en tu configuración de OpenCode:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neon3": {
      "type": "local",
      "command": ["neon3-mcp"],
      "enabled": true,
      "environment": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102",
        "NEON3_WGPU_ENDPOINT": "127.0.0.1:39103",
        "NEON3_PROJECTD_ENDPOINT": "127.0.0.1:39104"
      }
    }
  }
}

Copia skill/SKILL.md en el directorio de habilidades del host, o añade este repositorio como fuente de skills. Esta Skill está separada del servidor MCP para que sus reglas de autor articles estén disponibles cuando Neon3 esté sin conexión.

El MCP también expone el mismo material como recursos:

neon3://skill
neon3://references/overview
neon3://references/grammar
neon3://references/components
neon3://references/statecharts
neon3://references/interactions
neon3://references/diagnostics

Claude Desktop / Clientes MCP

{
  "mcpServers": {
    "neon3": {
      "command": "neon3-mcp",
      "env": {
        "NEON3_ROOT": "D:\\Neon3",
        "NEON3_UI_ENDPOINT": "127.0.0.1:39102"
      }
    }
  }
}

Herramientas

El bucle de autoría

reference -> capabilities -> generate NUI -> validate -> inspect -> submit -> diagnose

Ejemplo de NUI válido, tipado y semántico:

version 1
surface surface.example revision 1
budget nodes=32 bindings=16 instances=16 text=16 glyphs=1024 events=8 clips=64
input title text default text:empty
input can_save bool default false
surface root column w 520 h 240 gap 8 pad 16
  text heading value $title
  button save value "Save" enabled $can_save event document.save

NUI Flow no debe contener fetch, callbacks, código Python, rutas de archivos, coordenadas, manejadores de GPU ni expresiones arbitrarias.

Plantillas

templates/python-app y templates/node-app incluyen:

• Datos de aplicación neon3.app.json

• UI declarativa tipada ui/main.nui

• un cliente RPC mínimo con prefijo de longitud

• una prueba de protocolo determinista o verificación de sintaxis

La herramienta neon3_app_init solo escribe bajo NEON3_APP_ROOT (o el directorio actual si la variable no está definida).

Validar NUI sin un runtime en ejecución

$source = [string]::Join("`n", (Get-Content .\templates\node-app\ui\main.nui))
$request = @{ request_id = "manual-1"; operation = "validate"; sequence = 1; source = $source } | ConvertTo-Json -Compress
$request | cargo run --quiet -p neon-ui-runtime --manifest-path D:\Neon3\Cargo.toml --bin neon3_authoring_probe

El proceso emite JSONL. Un fallo del analizador o compilador devuelve el código de salida 1 e incluye diagnósticos estables y rangos de código fuente.

Iniciar los servicios headless de Neon3

El MCP no crea silenciosamente un segundoyo renderer:

cd D:\Neon3
scripts\run-neon-services.ps1

Después llama a neon3_capabilities, neon3_ui_snapshot o neon3_nui_submit desde el cliente IA.

Configuración

Todos los endpoints en vivo deben ser endpoints de loopback. El MCP no expone una herramienta de comandos de shell.

Solución de problemas

La sonda de autoría no puede iniciarse

cd D:\Neon3
cargo build -p neon-ui-runtime --bin neon3_authoring_probe
$env:NEON3_ROOT = 'D:\Neon3'

revision_conflict

Corre neon3_ui_snapshot, usa la revisión autoritativa devuelta y vuelve a enviar. No reintentes una mutación obsoleta.

Un servicio no está accesible

Comprueba el endpoint en neon3_capabilites. Inicia Ne-on3 con scripts\run-neon-services.ps1 o usa ne-on-dev para casos con ventana.

Desarrollo

npm install
npm test
node --check src/index.js
npm pack --dry-run

La prueba de protocolo usa un puntos fallo local determinista y verifica los IDs de solicitud, el enmarcado y la sale. JSON estructurada. El límita real de NUI lo verifica neon3_authoring_probe en el repositorio de Neon.

Relación del proyecto

Este repositorio es el capa de integración de IA. Ne-on3 sigue siendo el propiario del protocolo, pr, la gramática NUI, el runtime de UI, el runtime de4 la autoridad:

• MCP: https://ghejcom/dunco999/neon3-ai-authoring-mcp`

• Neon3: the https://github.com/unco999/Neon3-CiJian

Licencia

MIT. Ver LICENSE.