server.js

#!/usr/bin/env node
'use strict';

// ErgoScript Language Server.
//
// Speaks LSP 3.17 over stdio with no third-party dependencies, so it runs from
// a bare Node install:  node server.js --stdio

const { TextDocument } = require('./src/document');
const features = require('./src/features');
const { DEFAULT_SETTINGS } = require('./src/analyzer');

const PROTOCOL_ERROR = {
  ParseError: -32700,
  InvalidRequest: -32600,
  MethodNotFound: -32601,
  InvalidParams: -32602,
  InternalError: -32603,
  RequestCancelled: -32800,
};

class Connection {
  constructor(input, output) {
    this.input = input;
    this.output = output;
    this.buffer = Buffer.alloc(0);
    this.handlers = new Map();
    this.notificationHandlers = new Map();
    this.shuttingDown = false;
    this.nextId = 1;
    this.pending = new Map();
  }

  onRequest(method, handler) { this.handlers.set(method, handler); }
  onNotification(method, handler) { this.notificationHandlers.set(method, handler); }

  listen() {
    this.input.on('data', (chunk) => {
      this.buffer = Buffer.concat([this.buffer, chunk]);
      this.drain();
    });
    this.input.on('close', () => process.exit(this.shuttingDown ? 0 : 1));
  }

  drain() {
    for (;;) {
      const headerEnd = this.buffer.indexOf('\r\n\r\n');
      if (headerEnd < 0) return;
      const header = this.buffer.slice(0, headerEnd).toString('ascii');
      const match = /Content-Length:\s*(\d+)/i.exec(header);
      if (!match) {
        // Unrecoverable framing error: drop the header and resynchronise.
        this.buffer = this.buffer.slice(headerEnd + 4);
        continue;
      }
      const length = parseInt(match[1], 10);
      const bodyStart = headerEnd + 4;
      if (this.buffer.length < bodyStart + length) return;
      const body = this.buffer.slice(bodyStart, bodyStart + length).toString('utf8');
      this.buffer = this.buffer.slice(bodyStart + length);
      let message;
      try {
        message = JSON.parse(body);
      } catch (e) {
        this.sendError(null, PROTOCOL_ERROR.ParseError, `Invalid JSON: ${e.message}`);
        continue;
      }
      this.dispatch(message);
    }
  }

  dispatch(message) {
    if (message.id !== undefined && message.method === undefined) {
      const entry = this.pending.get(message.id);
      if (entry) {
        this.pending.delete(message.id);
        if (message.error) entry.reject(message.error); else entry.resolve(message.result);
      }
      return;
    }

    if (message.id === undefined) {
      const handler = this.notificationHandlers.get(message.method);
      if (handler) {
        try {
          handler(message.params || {});
        } catch (e) {
          this.log(`Error handling ${message.method}: ${e.stack || e.message}`);
        }
      }
      return;
    }

    const handler = this.handlers.get(message.method);
    if (!handler) {
      this.sendError(message.id, PROTOCOL_ERROR.MethodNotFound, `Unhandled method ${message.method}`);
      return;
    }
    Promise.resolve()
      .then(() => handler(message.params || {}))
      .then((result) => this.send({ jsonrpc: '2.0', id: message.id, result: result === undefined ? null : result }))
      .catch((e) => {
        this.log(`Error handling ${message.method}: ${e.stack || e.message}`);
        this.sendError(message.id, PROTOCOL_ERROR.InternalError, e.message || String(e));
      });
  }

  send(message) {
    const json = JSON.stringify(message);
    const payload = Buffer.from(json, 'utf8');
    this.output.write(`Content-Length: ${payload.length}\r\n\r\n`);
    this.output.write(payload);
  }

  sendError(id, code, message) {
    this.send({ jsonrpc: '2.0', id, error: { code, message } });
  }

  notify(method, params) {
    this.send({ jsonrpc: '2.0', method, params });
  }

  request(method, params) {
    const id = this.nextId++;
    return new Promise((resolve, reject) => {
      this.pending.set(id, { resolve, reject });
      this.send({ jsonrpc: '2.0', id, method, params });
    });
  }

  log(message) {
    this.notify('window/logMessage', { type: 3, message: `[ergoscript-lsp] ${message}` });
  }
}

// ---------------------------------------------------------------------------

const documents = new Map();
let settings = Object.assign({}, DEFAULT_SETTINGS);
let clientSupportsConfiguration = false;

const connection = new Connection(process.stdin, process.stdout);

function getDoc(params) {
  const uri = params.textDocument.uri;
  const doc = documents.get(uri);
  if (!doc) throw new Error(`Document not open: ${uri}`);
  return doc;
}

function analysisOf(doc) {
  return doc.analysis(settings);
}

function publishDiagnostics(doc) {
  try {
    const analysis = analysisOf(doc);
    connection.notify('textDocument/publishDiagnostics', {
      uri: doc.uri,
      version: doc.version,
      diagnostics: features.diagnostics(doc, analysis),
    });
  } catch (e) {
    connection.log(`Analysis failed for ${doc.uri}: ${e.stack || e.message}`);
    connection.notify('textDocument/publishDiagnostics', { uri: doc.uri, diagnostics: [] });
  }
}

function revalidateAll() {
  for (const doc of documents.values()) publishDiagnostics(doc);
}

connection.onRequest('initialize', (params) => {
  const caps = (params.capabilities || {}).workspace || {};
  clientSupportsConfiguration = !!caps.configuration;
  applySettings((params.initializationOptions || {}).settings);

  return {
    capabilities: {
      textDocumentSync: { openClose: true, change: 1, save: { includeText: false } },
      // `(`, `,` and `{` are here only so that a suggestion shaped like the
      // expected parameter can appear without pressing Ctrl+Space. Triggered by
      // one of those, completion returns *only* those shape suggestions, so the
      // popup opens where there is something worth showing and stays shut
      // otherwise — a brace anywhere else in a contract yields nothing.
      completionProvider: {
        triggerCharacters: ['.', '[', '(', ',', '{'],
        resolveProvider: false,
      },
      hoverProvider: true,
      signatureHelpProvider: { triggerCharacters: ['(', ','], retriggerCharacters: [','] },
      definitionProvider: true,
      referencesProvider: true,
      documentHighlightProvider: true,
      documentSymbolProvider: true,
      renameProvider: true,
      foldingRangeProvider: true,
      inlayHintProvider: true,
      codeActionProvider: { codeActionKinds: ['quickfix'] },
      semanticTokensProvider: {
        legend: {
          tokenTypes: features.SEMANTIC_TOKEN_TYPES,
          tokenModifiers: features.SEMANTIC_TOKEN_MODIFIERS,
        },
        full: true,
        range: false,
      },
    },
    serverInfo: { name: 'ErgoScript Language Server', version: '1.0.0' },
  };
});

connection.onNotification('initialized', async () => {
  if (clientSupportsConfiguration) {
    try {
      const result = await connection.request('workspace/configuration', {
        items: [{ section: 'ergoscript' }],
      });
      if (result && result[0]) { applySettings(result[0]); revalidateAll(); }
    } catch (e) {
      // The client may not answer; the defaults are fine.
    }
  }
});

function applySettings(incoming) {
  if (!incoming || typeof incoming !== 'object') return;
  const next = Object.assign({}, DEFAULT_SETTINGS);
  for (const key of Object.keys(DEFAULT_SETTINGS)) {
    if (incoming[key] !== undefined && incoming[key] !== null) next[key] = incoming[key];
  }
  settings = next;
}

connection.onNotification('workspace/didChangeConfiguration', (params) => {
  const incoming = (params.settings || {}).ergoscript || params.settings;
  applySettings(incoming);
  revalidateAll();
});

connection.onRequest('shutdown', () => {
  connection.shuttingDown = true;
  return null;
});
connection.onNotification('exit', () => process.exit(connection.shuttingDown ? 0 : 1));

// -- Document lifecycle -----------------------------------------------------

connection.onNotification('textDocument/didOpen', (params) => {
  const { uri, languageId, version, text } = params.textDocument;
  documents.set(uri, new TextDocument(uri, languageId, version, text));
  publishDiagnostics(documents.get(uri));
});

connection.onNotification('textDocument/didChange', (params) => {
  const doc = documents.get(params.textDocument.uri);
  if (!doc) return;
  // Full sync: the last content change carries the whole document.
  const changes = params.contentChanges || [];
  if (changes.length) doc.setText(changes[changes.length - 1].text);
  doc.version = params.textDocument.version;
  publishDiagnostics(doc);
});

connection.onNotification('textDocument/didSave', (params) => {
  const doc = documents.get(params.textDocument.uri);
  if (doc) publishDiagnostics(doc);
});

connection.onNotification('textDocument/didClose', (params) => {
  documents.delete(params.textDocument.uri);
  connection.notify('textDocument/publishDiagnostics', { uri: params.textDocument.uri, diagnostics: [] });
});

// -- Language features ------------------------------------------------------

connection.onRequest('textDocument/completion', (params) => {
  const doc = getDoc(params);
  return features.completion(doc, analysisOf(doc), params.position, params.context);
});

connection.onRequest('textDocument/hover', (params) => {
  const doc = getDoc(params);
  return features.hover(doc, analysisOf(doc), params.position);
});

connection.onRequest('textDocument/signatureHelp', (params) => {
  const doc = getDoc(params);
  return features.signatureHelp(doc, analysisOf(doc), params.position);
});

connection.onRequest('textDocument/definition', (params) => {
  const doc = getDoc(params);
  return features.definition(doc, analysisOf(doc), params.position);
});

connection.onRequest('textDocument/references', (params) => {
  const doc = getDoc(params);
  const include = params.context ? params.context.includeDeclaration : true;
  return features.references(doc, analysisOf(doc), params.position, include);
});

connection.onRequest('textDocument/documentHighlight', (params) => {
  const doc = getDoc(params);
  return features.documentHighlight(doc, analysisOf(doc), params.position);
});

connection.onRequest('textDocument/documentSymbol', (params) => {
  const doc = getDoc(params);
  return features.documentSymbols(doc, analysisOf(doc));
});

connection.onRequest('textDocument/rename', (params) => {
  const doc = getDoc(params);
  return features.rename(doc, analysisOf(doc), params.position, params.newName);
});

connection.onRequest('textDocument/foldingRange', (params) => {
  const doc = getDoc(params);
  return features.foldingRanges(doc);
});

connection.onRequest('textDocument/inlayHint', (params) => {
  const doc = getDoc(params);
  return features.inlayHints(doc, analysisOf(doc), params.range);
});

connection.onRequest('textDocument/semanticTokens/full', (params) => {
  const doc = getDoc(params);
  return features.semanticTokens(doc, analysisOf(doc));
});

connection.onRequest('textDocument/codeAction', (params) => {
  const doc = getDoc(params);
  return features.codeActions(doc, analysisOf(doc), params);
});

// ---------------------------------------------------------------------------

process.on('uncaughtException', (e) => {
  try { connection.log(`Uncaught exception: ${e.stack || e.message}`); } catch (_) { /* stdout gone */ }
});
process.on('unhandledRejection', (e) => {
  try { connection.log(`Unhandled rejection: ${(e && e.stack) || e}`); } catch (_) { /* stdout gone */ }
});

connection.listen();