aontu 0.45.1 → 0.48.0

package/src/lang.ts

@@ -5,42 +5,43 @@
 
 import {
   Jsonic,
+  Tabnas,
   Plugin,
   Rule,
   RuleSpec,
   Context as JsonicContext,
   JsonicError,
-} from 'jsonic'
+} from '@tabnas/jsonic'
 
 
-import { Debug } from 'jsonic/debug'
+import { Debug } from '@tabnas/debug'
 
 import {
   MultiSource
-} from '@jsonic/multisource'
+} from '@tabnas/multisource'
 
-// TODO: @jsonic/multisource should support virtual fs
+// TODO: @tabnas/multisource should support virtual fs
 
 import {
   makeFileResolver
-} from '@jsonic/multisource/resolver/file'
+} from '@tabnas/multisource/resolver/file'
 
 import {
   makePkgResolver
-} from '@jsonic/multisource/resolver/pkg'
+} from '@tabnas/multisource/resolver/pkg'
 
 import {
   makeMemResolver
-} from '@jsonic/multisource/resolver/mem'
+} from '@tabnas/multisource/resolver/mem'
 
 import {
   Expr,
   Op,
-} from '@jsonic/expr'
+} from '@tabnas/expr'
 
 import {
   Path
-} from '@jsonic/path'
+} from '@tabnas/path'
 
 import type {
   Val,
@@ -93,9 +94,11 @@ import { OpenFuncVal } from './val/OpenFuncVal'
 import { SuperFuncVal } from './val/SuperFuncVal'
 
 
+const asPlugin = (p: unknown): Plugin => p as Plugin
+
 let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
 
-  jsonic.use(Path)
+  jsonic.use(asPlugin(Path))
 
   // TODO: refactor Val constructor
   // let addsite = (v: Val, p: string[]) => (v.path = [...(p || [])], v)
@@ -250,6 +253,8 @@ help isolate the syntax error.`,
     'negative-prefix': (r: Rule, ctx: JsonicContext, _op: Op, terms: any) => {
       let val = terms[0]
       val.peg = -1 * val.peg
+      // Normalize -0 to 0 (keeps the AST and canon free of negative zero).
+      if (0 === val.peg) val.peg = 0
       return addsite(val, r, ctx)
     },
 
@@ -277,7 +282,7 @@ help isolate the syntax error.`,
 
 
   jsonic
-    .use(Expr, {
+    .use(asPlugin(Expr), {
       op: {
         // disjunct < conjunct: c & b | a -> (c & b) | a
         'conjunct': {
@@ -374,13 +379,23 @@ help isolate the syntax error.`,
 
     rs
       .open([
-        { s: [CJ, CL], p: 'map', b: 2, n: { pk: 1 }, g: 'spread' },
+        {
+          s: [CJ, CL], p: 'map', b: 2, n: { pk: 1 },
+          // @tabnas seeds a descended rule's node from its parent; without
+          // a fresh node here the nested spread map (`a:&:{x:1}`) would
+          // share the parent map's node object and self-reference.
+          a: (r: Rule) => { r.node = {} },
+          g: 'spread'
+        },
 
         {
           s: [OPTKEY, QM],
           c: (r) => 0 == r.d,
           p: 'map',
           b: 2,
+          // Fresh node (see spread alt above): the optional dive descends
+          // to a map and must not share the parent's node object.
+          a: (r: Rule) => { r.node = {} },
           g: 'pair,jsonic,top,aontu-optional',
         },
 
@@ -389,12 +404,13 @@ help isolate the syntax error.`,
           p: 'map',
           b: 2,
           n: { pk: 1 },
+          a: (r: Rule) => { r.node = {} },
           g: 'pair,jsonic,top,dive,aontu-optional',
         },
 
       ])
 
-      .bc((r: Rule, ctx: JsonicContext) => {
+      .ac((r: Rule, ctx: JsonicContext) => {
 
         let valnode: Val = r.node
         let valtype = typeof valnode
@@ -555,7 +571,7 @@ help isolate the syntax error.`,
         }
       ])
 
-      // NOTE: manually adjust path - @jsonic/path ignores as not pair:true
+      // NOTE: manually adjust path - @tabnas/path ignores as not pair:true
       .ao((r) => {
         if (0 < r.d && r.u.spread) {
           r.child.k.path = [...r.k.path, '&']
@@ -640,6 +656,13 @@ help isolate the syntax error.`,
 
 
 
+// SECURITY: the default resolver reads any file/package the process can
+// reach — @"path" follows relative paths (`@"../../etc/passwd"`) and
+// symlinks with no containment check, and @"pkg" can require() arbitrary
+// installed modules. This is intentional for the CLI, but it means a
+// `.aon` source can read referenced files; the LSP uses this same
+// resolver, so treat opening an untrusted source as running it. Pass a
+// confined `options.resolver` to restrict reads in less-trusted contexts.
 function makeModelResolver(options: any) {
   const useRequire = options.require || require
 
@@ -662,7 +685,7 @@ function makeModelResolver(options: any) {
     popts: any,
     rule: Rule,
     ctx: JsonicContext,
-    jsonic: Jsonic
+    jsonic: Tabnas
   ) {
 
     let path = 'string' === typeof spec ? spec : spec?.peg
@@ -711,20 +734,25 @@ class Lang {
     this.jsonic = Jsonic.make()
 
     if (this.opts.debug) {
-      this.jsonic.use(Debug, {
+      this.jsonic.use(asPlugin(Debug), {
         trace: this.opts.trace
       })
     }
 
     this.jsonic
-      .use(AontuJsonic)
-      .use(MultiSource, {
+      .use(asPlugin(MultiSource), {
         resolver: options?.resolver || modelResolver,
+        // `.aon` is the preferred Aontu source extension; `.aontu` also
+        // works. `.jsonic` is retired (no longer auto-resolved); the
+        // default `['jsonic','jsc','json','js']` is overridden here.
+        // (Upstream option name is the misspelled `implictExt`.)
+        implictExt: ['aon', 'aontu'],
         processor: {
           aontu: 'jsonic',
           aon: 'jsonic',
         }
       })
+      .use(AontuJsonic)
   }
 
 

package/src/lsp-server.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// Aontu Language Server (stdio).
+//
+//   aontu-lsp
+//
+// Speaks LSP over stdio (JSON-RPC with Content-Length framing) and
+// publishes unification diagnostics as `.aontu` files are edited. This
+// binary is intentionally thin: all protocol logic lives in the reusable
+// library ./lsp (LspHandler + computeDiagnostics). See docs/lsp.md for
+// editor configuration.
+
+import { LspHandler, Message, OutMessage } from './lsp'
+
+
+// A byte-level LSP framing codec: feed it incoming chunks, give it a
+// handler, and it decodes Content-Length frames, dispatches them, and
+// writes framed replies. Kept transport-injectable (write/onExit) so it
+// can be unit-tested without real stdio.
+class FrameCodec {
+  private buffer = Buffer.alloc(0)
+
+  constructor(
+    private handler: LspHandler,
+    private write: (chunk: Buffer) => void,
+    private onExit: (code: number) => void,
+  ) { }
+
+  // Feed a chunk of incoming bytes; processes any complete frames.
+  push(chunk: Buffer) {
+    this.buffer = Buffer.concat([this.buffer, chunk])
+    this.drain()
+  }
+
+  // Called when the input stream ends.
+  end() {
+    this.onExit(this.handler.exitCode)
+  }
+
+  private drain() {
+    for (; ;) {
+      const headerEnd = this.buffer.indexOf('\r\n\r\n')
+      if (headerEnd < 0) return
+
+      const header = this.buffer.subarray(0, headerEnd).toString('ascii')
+      const match = /Content-Length:\s*(\d+)/i.exec(header)
+      if (null == match) {
+        // Malformed header block: skip past it and continue.
+        this.buffer = this.buffer.subarray(headerEnd + 4)
+        continue
+      }
+
+      const length = parseInt(match[1], 10)
+      const bodyStart = headerEnd + 4
+      if (this.buffer.length < bodyStart + length) return // need more bytes
+
+      const body = this.buffer.subarray(bodyStart, bodyStart + length).toString('utf8')
+      this.buffer = this.buffer.subarray(bodyStart + length)
+
+      let msg: Message
+      try {
+        msg = JSON.parse(body)
+      }
+      catch {
+        continue // ignore unparseable frame
+      }
+
+      for (const out of this.handler.handle(msg)) {
+        this.send(out)
+      }
+
+      if (this.handler.shouldExit) {
+        this.onExit(this.handler.exitCode)
+        return
+      }
+    }
+  }
+
+  private send(out: OutMessage) {
+    const body = Buffer.from(JSON.stringify(out), 'utf8')
+    this.write(Buffer.from('Content-Length: ' + body.length + '\r\n\r\n', 'ascii'))
+    this.write(body)
+  }
+}
+
+
+function main() {
+  const handler = new LspHandler()
+  const codec = new FrameCodec(
+    handler,
+    (chunk) => process.stdout.write(chunk),
+    (code) => process.exit(code),
+  )
+
+  process.stdin.on('data', (chunk: Buffer) => codec.push(chunk))
+  process.stdin.on('end', () => codec.end())
+}
+
+
+// Only auto-run when invoked as a program, not when imported by tests.
+if (require.main === module) {
+  main()
+}
+
+
+export {
+  FrameCodec,
+}