@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/tools/rmt-language-server/protocol.js

@@ -324,6 +324,9 @@ function toLspCodeAction(action = {}) {
       pointer: action.pointer || null,
       safe: action.safe !== false,
       confidence: action.confidence || null,
+      preview: action.preview || null,
+      fixAllActionCount: action.fixAllActionCount || null,
+      diagnosticCodes: Array.isArray(action.diagnosticCodes) ? action.diagnosticCodes : [],
       workpackage: action.workpackage || RMT_LANGUAGE_SERVER_WORKPACKAGE
     }
   };

package/tools/rmt-language-server/server.d.ts

@@ -3,6 +3,7 @@ import type { RmtLanguageServiceProvider, RmtToolingClassConstructor, RmtTooling
 
 export declare const createCapabilities: RmtToolingFactory;
 export declare const createRmtLanguageServer: RmtToolingFactory;
+export declare const isWritableTransportOpen: RmtToolingFunction<boolean>;
 export declare const RMT_LANGUAGE_SERVER_MODULE_PATH: RmtToolingConstant;
 export declare const RMT_LANGUAGE_SERVER_PACKAGE_SCRIPT: RmtToolingConstant;
 export declare const RMT_LANGUAGE_SERVER_REPORT_SCHEMA: RmtToolingConstant;
@@ -13,3 +14,4 @@ export declare const RmtLanguageServer: RmtToolingClassConstructor<RmtLanguageSe
 export declare const runStdioServer: RmtToolingFunction;
 export declare const SERVER_NAME: RmtToolingConstant;
 export declare const SERVER_VERSION: RmtToolingConstant;
+export declare const writeProtocolOutput: RmtToolingFunction;

package/tools/rmt-language-server/server.js

@@ -27,11 +27,14 @@ const {
 } = require('../rmt-language/code-actions');
 const {
   analyzeRmtVNextToolingSource,
+  createRmtVNextPrimitiveCommandHandoff,
   findRmtVNextPointerAtPosition,
+  getRmtVNextToolingCodeActions,
   getRmtVNextToolingCompletions,
   getRmtVNextToolingDefinition,
   getRmtVNextToolingDocumentSymbols,
   getRmtVNextToolingHover,
+  RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND,
   isLikelyRmtVNextSource,
   lintRmtVNextToolingSource
 } = require('../rmt-language/vnext-tooling');
@@ -170,7 +173,10 @@ function createCapabilities() {
     documentSymbolProvider: true,
     definitionProvider: true,
     codeActionProvider: {
-      codeActionKinds: ['quickfix']
+      codeActionKinds: ['quickfix', 'source.fixAll', 'source.fixAll.rmt.vnext.primitives']
+    },
+    executeCommandProvider: {
+      commands: [RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND]
     }
   };
 }
@@ -378,6 +384,7 @@ class RmtLanguageServer {
   completion(params = {}) {
     const uri = normalizeString(params.textDocument && params.textDocument.uri);
     const analysis = this.analyzeDocument(uri);
+    const xtend = params.xtend || {};
 
     if (!analysis) {
       return {
@@ -386,22 +393,23 @@ class RmtLanguageServer {
       };
     }
 
-    const pointer = params.xtend && params.xtend.pointer
-      ? params.xtend.pointer
+    const pointer = xtend.pointer
+      ? xtend.pointer
       : this.getPointerAtPosition(uri, params.position || {});
     const report = analysis.languageMode === 'vnext'
       ? getRmtVNextToolingCompletions(analysis.input, {
         rootDir: this.rootDir,
         analysis: analysis.graph,
-        pointer,
-        prefix: params.xtend && params.xtend.prefix ? params.xtend.prefix : '',
-        context: params.xtend && params.xtend.context ? params.xtend.context : null
+        pointer: xtend.pointer || null,
+        prefix: xtend.prefix || '',
+        context: xtend.context || null,
+        position: params.position || null
       })
       : getRmtCompletions(analysis.input, {
         rootDir: this.rootDir,
         graph: analysis.graph,
         pointer,
-        prefix: params.xtend && params.xtend.prefix ? params.xtend.prefix : ''
+        prefix: xtend.prefix || ''
       });
 
     return {
@@ -491,20 +499,46 @@ class RmtLanguageServer {
       return [];
     }
 
-    if (analysis.languageMode === 'vnext') {
-      return [];
-    }
-
-    const report = getRmtCodeActions(analysis.input, {
-      rootDir: this.rootDir,
-      graph: analysis.graph,
-      lintReport: analysis.linterReport,
-      contextDiagnostics: params.context && params.context.diagnostics ? params.context.diagnostics : []
-    });
+    const report = analysis.languageMode === 'vnext'
+      ? getRmtVNextToolingCodeActions(analysis.input, {
+        rootDir: this.rootDir,
+        analysis: analysis.graph,
+        lintReport: analysis.linterReport,
+        contextDiagnostics: params.context && params.context.diagnostics ? params.context.diagnostics : []
+      })
+      : getRmtCodeActions(analysis.input, {
+        rootDir: this.rootDir,
+        graph: analysis.graph,
+        lintReport: analysis.linterReport,
+        contextDiagnostics: params.context && params.context.diagnostics ? params.context.diagnostics : []
+      });
 
     return toArray(report.actions).map(toLspCodeAction);
   }
 
+  executeCommand(params = {}) {
+    const command = normalizeString(params.command);
+    const args = toArray(params.arguments);
+
+    if (command === RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND) {
+      return createRmtVNextPrimitiveCommandHandoff({
+        command,
+        arguments: args
+      }, {
+        rootDir: this.rootDir
+      });
+    }
+
+    return {
+      schema: 'xtend.rmt.language-server-command-result.v1',
+      workpackage: RMT_LANGUAGE_SERVER_WORKPACKAGE,
+      status: 'unsupported_command',
+      ok: false,
+      command,
+      supportedCommands: [RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND]
+    };
+  }
+
   handleRequest(message = {}) {
     try {
       switch (message.method) {
@@ -523,6 +557,8 @@ class RmtLanguageServer {
           return createJsonRpcResponse(message.id, this.definition(message.params || {}));
         case 'textDocument/codeAction':
           return createJsonRpcResponse(message.id, this.codeAction(message.params || {}));
+        case 'workspace/executeCommand':
+          return createJsonRpcResponse(message.id, this.executeCommand(message.params || {}));
         default:
           return createJsonRpcError(message.id, -32601, `RMT Language Server method not found: ${message.method}`);
       }
@@ -584,21 +620,137 @@ function createRmtLanguageServer(options = {}) {
   return new RmtLanguageServer(options);
 }
 
+function isWritableTransportOpen(stream) {
+  return !!(
+    stream &&
+    typeof stream.write === 'function' &&
+    stream.destroyed !== true &&
+    stream.writableEnded !== true &&
+    stream.writableFinished !== true &&
+    stream.closed !== true &&
+    stream.writable !== false
+  );
+}
+
+function writeProtocolOutput(stream, encoded) {
+  if (!isWritableTransportOpen(stream)) {
+    return {
+      schema: RMT_LANGUAGE_SERVER_REPORT_SCHEMA,
+      workpackage: RMT_LANGUAGE_SERVER_WORKPACKAGE,
+      ok: false,
+      status: 'transport-closed',
+      reason: 'stdio output stream is no longer writable'
+    };
+  }
+
+  try {
+    const accepted = stream.write(encoded);
+    return {
+      schema: RMT_LANGUAGE_SERVER_REPORT_SCHEMA,
+      workpackage: RMT_LANGUAGE_SERVER_WORKPACKAGE,
+      ok: true,
+      status: accepted === false ? 'backpressure' : 'written',
+      backpressure: accepted === false
+    };
+  } catch (error) {
+    return {
+      schema: RMT_LANGUAGE_SERVER_REPORT_SCHEMA,
+      workpackage: RMT_LANGUAGE_SERVER_WORKPACKAGE,
+      ok: false,
+      status: 'write-failed',
+      code: error && error.code ? error.code : null,
+      reason: error && error.message ? error.message : String(error)
+    };
+  }
+}
+
 function runStdioServer(options = {}) {
   const server = createRmtLanguageServer(options);
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const exitProcess = typeof options.exitProcess === 'function'
+    ? options.exitProcess
+    : (options.exitProcess === false ? null : process.exit.bind(process));
+  let transportClosed = false;
+
+  const closeTransport = (reason) => {
+    transportClosed = true;
+    server.transportClosed = true;
+    server.transportCloseReason = reason || null;
+    if (input && typeof input.pause === 'function') {
+      input.pause();
+    }
+  };
+
+  const maybeExit = (code) => {
+    if (exitProcess) {
+      exitProcess(code);
+    } else {
+      process.exitCode = code;
+    }
+  };
+
+  if (output && typeof output.on === 'function') {
+    output.on('error', (error) => {
+      closeTransport({
+        status: 'output-error',
+        code: error && error.code ? error.code : null,
+        reason: error && error.message ? error.message : String(error)
+      });
+    });
+  }
+
+  if (input && typeof input.on === 'function') {
+    input.on('end', () => {
+      closeTransport({ status: 'input-ended' });
+      maybeExit(server.shutdownRequested ? 0 : 0);
+    });
+    input.on('close', () => {
+      closeTransport({ status: 'input-closed' });
+    });
+    input.on('error', (error) => {
+      closeTransport({
+        status: 'input-error',
+        code: error && error.code ? error.code : null,
+        reason: error && error.message ? error.message : String(error)
+      });
+      maybeExit(1);
+    });
+  }
+
+  input.on('data', (chunk) => {
+    if (transportClosed) {
+      return;
+    }
+
+    let result = null;
+    try {
+      result = server.acceptProtocolData(chunk);
+    } catch (error) {
+      result = {
+        encodedOutputs: [
+          encodeProtocolMessage(createJsonRpcError(null, -32700, error && error.message ? error.message : String(error)))
+        ]
+      };
+    }
 
-  process.stdin.on('data', (chunk) => {
-    const result = server.acceptProtocolData(chunk);
     result.encodedOutputs.forEach((encoded) => {
-      process.stdout.write(encoded);
+      if (transportClosed) {
+        return;
+      }
+      const writeResult = writeProtocolOutput(output, encoded);
+      if (!writeResult.ok) {
+        closeTransport(writeResult);
+      }
     });
 
     if (server.exitRequested) {
-      process.exit(server.shutdownRequested ? 0 : 1);
+      closeTransport({ status: 'lsp-exit-requested' });
+      maybeExit(server.shutdownRequested ? 0 : 1);
     }
   });
 
-  process.stdin.resume();
+  input.resume();
   return server;
 }
 
@@ -618,5 +770,7 @@ module.exports = {
   RmtLanguageServer,
   createCapabilities,
   createRmtLanguageServer,
+  isWritableTransportOpen,
+  writeProtocolOutput,
   runStdioServer
 };

package/tools/rmt-linter/cli.d.ts

@@ -3,8 +3,10 @@ import type { RmtLanguageServiceReport, RmtParseResult, RmtToolingConstant, RmtT
 
 export declare const buildHelpText: RmtToolingFactory;
 export declare const collectRmtFiles: RmtToolingFunction;
+export declare const formatProblemMatcherDiagnostic: RmtToolingFunction<string>;
 export declare const lintFiles: RmtToolingFunction<RmtLanguageServiceReport>;
 export declare const parseArgs: RmtToolingFunction<RmtParseResult>;
+export declare const printProblemMatcherReport: RmtToolingFunction;
 export declare const RMT_LINTER_CLI_MODULE_PATH: RmtToolingConstant;
 export declare const RMT_LINTER_CLI_PACKAGE_SCRIPT: RmtToolingConstant;
 export declare const RMT_LINTER_CLI_REPORT_SCHEMA: RmtToolingConstant;

package/tools/rmt-linter/cli.js

@@ -16,6 +16,8 @@ const RMT_LINTER_CLI_MODULE_PATH = 'tools/rmt-linter/cli.js';
 const RMT_LINTER_CLI_SUITE_PATH = 'tests/rmt-language/rmt_linter_cli_suite.js';
 const RMT_LINTER_CLI_PACKAGE_SCRIPT = 'npm run test:rmt-linter-cli';
 const DEFAULT_FAIL_ON = 'error';
+const DEFAULT_FORMAT = 'text';
+const OUTPUT_FORMATS = new Set(['text', 'json', 'problem-matcher']);
 const SEVERITY_RANK = {
   error: 0,
   warning: 1,
@@ -31,11 +33,16 @@ function normalizeSeverity(value) {
   return Object.prototype.hasOwnProperty.call(SEVERITY_RANK, value) ? value : DEFAULT_FAIL_ON;
 }
 
+function normalizeOutputFormat(value) {
+  return OUTPUT_FORMATS.has(value) ? value : DEFAULT_FORMAT;
+}
+
 function parseArgs(args = [], inheritedOptions = {}) {
   const parsed = {
     help: false,
     json: !!inheritedOptions.json,
     agent: !!inheritedOptions.agent,
+    format: inheritedOptions.format || (inheritedOptions.json ? 'json' : DEFAULT_FORMAT),
     failOn: inheritedOptions.failOn || DEFAULT_FAIL_ON,
     rootDir: inheritedOptions.rootDir || process.cwd(),
     targets: []
@@ -52,12 +59,32 @@ function parseArgs(args = [], inheritedOptions = {}) {
 
     if (arg === '--json') {
       parsed.json = true;
+      parsed.format = 'json';
       continue;
     }
 
     if (arg === '--agent' || arg === '--agent-report') {
       parsed.agent = true;
       parsed.json = true;
+      parsed.format = 'json';
+      continue;
+    }
+
+    if (arg === '--problem-matcher') {
+      parsed.format = 'problem-matcher';
+      continue;
+    }
+
+    if (arg === '--format') {
+      parsed.format = normalizeOutputFormat(args[index + 1]);
+      parsed.json = parsed.format === 'json';
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--format=')) {
+      parsed.format = normalizeOutputFormat(arg.slice('--format='.length));
+      parsed.json = parsed.format === 'json';
       continue;
     }
 
@@ -91,6 +118,7 @@ function parseArgs(args = [], inheritedOptions = {}) {
   }
 
   parsed.failOn = normalizeSeverity(parsed.failOn);
+  parsed.format = parsed.json ? 'json' : normalizeOutputFormat(parsed.format);
   parsed.rootDir = path.resolve(parsed.rootDir || process.cwd());
   parsed.targets = positionals;
 
@@ -108,10 +136,13 @@ function buildHelpText() {
     '  xt rmt lint "docs/**/*.rmt" --json',
     '  xt rmt lint app.rmt --agent',
     '  xt rmt lint app.rmt --fail-on warning',
+    '  xt rmt lint app.rmt --format problem-matcher',
     '',
     'Options:',
     '  --json              Print machine-readable JSON report.',
     '  --agent             Print AI-agent repair report with fix order and no-op explanations.',
+    '  --format <format>   text, json or problem-matcher. Default: text.',
+    '  --problem-matcher   Alias for --format problem-matcher.',
     '  --fail-on <level>   error, warning, info or hint. Default: error.',
     '  --root <dir>        Workspace root for relative targets.',
     '  --help              Print this help text.'
@@ -386,6 +417,29 @@ function printTextReport(report, stdout, rootDir) {
   });
 }
 
+function sanitizeProblemMatcherMessage(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function normalizeProblemMatcherSeverity(severity) {
+  return severity === 'hint' ? 'info' : normalizeSeverity(severity);
+}
+
+function formatProblemMatcherDiagnostic(diagnostic, rootDir) {
+  const location = formatLocation(diagnostic, rootDir);
+  const severity = normalizeProblemMatcherSeverity(diagnostic.severity);
+  const code = diagnostic.code || 'rmt.diagnostic';
+  const message = sanitizeProblemMatcherMessage(diagnostic.message || code);
+
+  return `${severity} ${code} ${location} ${message}`;
+}
+
+function printProblemMatcherReport(report, stdout, rootDir) {
+  report.diagnostics.forEach((diagnostic) => {
+    writeLine(stdout, formatProblemMatcherDiagnostic(diagnostic, rootDir));
+  });
+}
+
 function runRmtLinterCli(args = process.argv.slice(2), io = {}) {
   const stdout = io.stdout || process.stdout;
   const stderr = io.stderr || process.stderr;
@@ -400,6 +454,8 @@ function runRmtLinterCli(args = process.argv.slice(2), io = {}) {
     const report = createEmptyFailureReport('Kein RMT Target angegeben. Nutze `xt rmt lint <file-or-dir>`.', options);
     if (options.json) {
       writeLine(stdout, JSON.stringify(report, null, 2));
+    } else if (options.format === 'problem-matcher') {
+      printProblemMatcherReport(report, stdout, options.rootDir);
     } else {
       writeLine(stderr, report.diagnostics[0].message);
     }
@@ -412,6 +468,8 @@ function runRmtLinterCli(args = process.argv.slice(2), io = {}) {
     const report = createEmptyFailureReport('Keine .rmt oder .rmt.json Dateien fuer die angegebenen Targets gefunden.', options);
     if (options.json) {
       writeLine(stdout, JSON.stringify(report, null, 2));
+    } else if (options.format === 'problem-matcher') {
+      printProblemMatcherReport(report, stdout, options.rootDir);
     } else {
       writeLine(stderr, report.diagnostics[0].message);
     }
@@ -424,6 +482,8 @@ function runRmtLinterCli(args = process.argv.slice(2), io = {}) {
 
   if (options.json || options.agent) {
     writeLine(stdout, JSON.stringify(report, null, 2));
+  } else if (options.format === 'problem-matcher') {
+    printProblemMatcherReport(report, stdout, options.rootDir);
   } else {
     printTextReport(report, stdout, options.rootDir);
   }
@@ -444,7 +504,9 @@ module.exports = {
   RMT_LINTER_CLI_WORKPACKAGE,
   buildHelpText,
   collectRmtFiles,
+  formatProblemMatcherDiagnostic,
   lintFiles,
   parseArgs,
+  printProblemMatcherReport,
   runRmtLinterCli
 };

package/xtend-builder/generators/registry.js

@@ -19,6 +19,9 @@ const {
 const {
   createRmtAppBuild
 } = require('./rmt-build');
+const {
+  createRmtAppPlatformBuild
+} = require('./rmt-app-platform');
 
 const GENERATOR_REGISTRY_SCHEMA = 'xtend.scaffold.generator-registry.v1';
 
@@ -78,6 +81,14 @@ const GENERATORS = [
     owner: 'WP-E17-04',
     description: 'Compiles an RMT vNext template into Core JSON, XTend component/app, host, browser smoke and Scaffold report artifacts.',
     run: createRmtAppBuild
+  },
+  {
+    id: 'rmt-app-platform',
+    command: 'rmt-app-platform',
+    status: 'rmt-app-platform-diagnostics-source-map-and-scaffold-report',
+    owner: 'WP-E18-11',
+    description: 'Builds diagnostics, source maps and scaffold reports for generic Epic 18 RMT App Platform sources.',
+    run: createRmtAppPlatformBuild
   }
 ];