plccheck 2.3.2 → 2.5.0

package/README.md

@@ -13,8 +13,37 @@ npx plccheck check ./path/to/project
 - `plccheck serve` (LSP server over stdio)
 - `plccheck check <files-or-folders...>`
 - `plccheck emit --target <language> <file>`
+- `plccheck test [--filter <text>] [--events-json] [--coverage-json <file>] [--coverage-lcov <file>] [--coverage-branches] <file-or-folder>`
 - `plccheck version`
 
+## Testing and Coverage
+
+Run tests for a PLC root:
+
+```bash
+npx plccheck test ./my-plc-project
+```
+
+Request coverage artifacts in JSON and LCOV formats:
+
+```bash
+npx plccheck test ./my-plc-project --coverage-json coverage.json --coverage-lcov coverage.info
+```
+
+For zero-config discovery in the Coverage Gutters VS Code extension, write the LCOV tracefile as `lcov.info` instead:
+
+```bash
+npx plccheck test ./my-plc-project --coverage-json coverage.json --coverage-lcov lcov.info
+```
+
+Keep the default Stage 1 line-focused coverage view, but opt into additive Stage 2 branch data when needed:
+
+```bash
+npx plccheck test ./my-plc-project --coverage-json coverage.json --coverage-branches
+```
+
+Note: `--events-json` prints a stream of execution events to stdout, while `--coverage-json` writes a finalized coverage report to a file. By default, the JSON artifact stays statement/line-focused and still includes function summaries/details where available, and LCOV includes the matching function records. `--coverage-branches` widens the JSON artifact with additive branch summaries/details and also adds LCOV branch records where branch runtime data is available. For AI analysis, use the file artifact from `--coverage-json`.
+
 ## Publishing (maintainers)
 
 Initial publish requires npm auth once (to create the package entries in the registry). After that, releases use GitHub Actions + npm Trusted Publishing.

package/bin/plccheck.js

@@ -32,6 +32,35 @@ if (!pkg) {
   process.exit(1);
 }
 
+const REPO_DEV_PACKAGE_NAME = 'dynamic-siemens-language-support';
+
+const coverageValueFlags = [
+  '--coverage-json', '-coverage-json',
+  '--coverage-lcov', '-coverage-lcov'
+];
+
+const testValueFlags = [
+  '--filter', '-filter',
+  '--parallel', '-parallel',
+  '--coverage-json', '-coverage-json',
+  '--coverage-lcov', '-coverage-lcov',
+  '--module', '-module',
+  '--entry-ob', '-entry-ob'
+];
+
+const commandValueFlags = {
+  check: ['--jobs', '-jobs'],
+  emit: ['--target', '-target'],
+  transpile: ['--from', '-from', '--to', '-to'],
+  'go-gen': ['--out', '-out', '--module', '-module', '--entry-ob', '-entry-ob'],
+  test: testValueFlags,
+};
+
+const pathValueFlags = [
+  ...coverageValueFlags,
+  '--out', '-out',
+];
+
 function cacheRoot() {
   if (process.env.XDG_CACHE_HOME) return path.join(process.env.XDG_CACHE_HOME, 'plccheck');
   if (process.platform === 'darwin') return path.join(os.homedir(), 'Library', 'Caches', 'plccheck');
@@ -186,7 +215,25 @@ function readOptionalDepVersion(pkgName) {
   }
 }
 
+function isRepoDevelopmentMode(rootDir = path.join(__dirname, '..', '..', '..')) {
+  const repoRoot = path.resolve(rootDir);
+  const localGoMod = path.join(repoRoot, 'go_lsp', 'go.mod');
+  const localMain = path.join(repoRoot, 'go_lsp', 'cmd', 'siemens-lsp', 'main.go');
+  const localExtension = path.join(repoRoot, 'client', 'src', 'extension.ts');
+  if (!fs.existsSync(localGoMod) || !fs.existsSync(localMain) || !fs.existsSync(localExtension)) {
+    return false;
+  }
+  try {
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+    return pkgJson && pkgJson.name === REPO_DEV_PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+
 async function resolveBinaryPath() {
+  if (isRepoDevelopmentMode()) return 'go';
+
   try {
     return require(pkg);
   } catch (err) {
@@ -225,28 +272,156 @@ async function resolveBinaryPath() {
   return binPath;
 }
 
-let binaryPath;
-resolveBinaryPath()
-  .then((p) => {
-    binaryPath = p;
-    const child = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit' });
+function resolveCoverageOutputPaths(args, cwd) {
+  const nextArgs = args.slice();
+  for (let i = 0; i < nextArgs.length; i++) {
+    const baseFlag = nextArgs[i].split('=')[0];
+    if (!coverageValueFlags.includes(baseFlag)) {
+      continue;
+    }
+    if (nextArgs[i].includes('=')) {
+      const value = nextArgs[i].slice(nextArgs[i].indexOf('=') + 1);
+      if (value && !path.isAbsolute(value)) {
+        nextArgs[i] = `${baseFlag}=${path.resolve(cwd, value)}`;
+      }
+      continue;
+    }
+    if (i + 1 < nextArgs.length && !nextArgs[i + 1].startsWith('-') && !path.isAbsolute(nextArgs[i + 1])) {
+      nextArgs[i + 1] = path.resolve(cwd, nextArgs[i + 1]);
+    }
+  }
+  return nextArgs;
+}
+
+function resolveTestPositionals(args, cwd) {
+  const nextArgs = args.slice();
+  if (nextArgs[0] !== 'test') {
+    return nextArgs;
+  }
+  for (let i = 1; i < nextArgs.length; i++) {
+    if (nextArgs[i].startsWith('-')) {
+      continue;
+    }
+    const prev = nextArgs[i - 1];
+    if (testValueFlags.includes(prev)) {
+      continue;
+    }
+    if (!path.isAbsolute(nextArgs[i])) {
+      nextArgs[i] = path.resolve(cwd, nextArgs[i]);
+    }
+  }
+  return nextArgs;
+}
+
+function resolveGoRunPaths(args, cwd) {
+  const nextArgs = args.slice();
+  if (nextArgs.length === 0) {
+    return nextArgs;
+  }
+  const valueFlags = commandValueFlags[nextArgs[0]] || [];
+  for (let i = 1; i < nextArgs.length; i++) {
+    const arg = nextArgs[i];
+    if (arg.startsWith('-')) {
+      const baseFlag = arg.split('=')[0];
+      if (arg.includes('=')) {
+        const value = arg.slice(arg.indexOf('=') + 1);
+        if (value && pathValueFlags.includes(baseFlag) && !path.isAbsolute(value)) {
+          nextArgs[i] = `${baseFlag}=${path.resolve(cwd, value)}`;
+        }
+        continue;
+      }
+      if (valueFlags.includes(baseFlag) && i + 1 < nextArgs.length) {
+        if (pathValueFlags.includes(baseFlag) && !nextArgs[i + 1].startsWith('-') && !path.isAbsolute(nextArgs[i + 1])) {
+          nextArgs[i + 1] = path.resolve(cwd, nextArgs[i + 1]);
+        }
+        i++;
+      }
+      continue;
+    }
+    if (!path.isAbsolute(arg)) {
+      nextArgs[i] = path.resolve(cwd, arg);
+    }
+  }
+  return nextArgs;
+}
+
+function reorderTestArgs(args) {
+  if (args[0] !== 'test' && !(args[0] === 'run' && args[1] === './cmd/siemens-lsp' && args[2] === 'test')) {
+    return args.slice();
+  }
+  const isGoRun = args[0] === 'run';
+  const testArgsStartIndex = isGoRun ? 3 : 1;
+  const testPrefix = args.slice(0, testArgsStartIndex);
+  const testArgs = args.slice(testArgsStartIndex);
+  const flags = [];
+  const positionals = [];
+  for (let i = 0; i < testArgs.length; i++) {
+    if (testArgs[i].startsWith('-')) {
+      flags.push(testArgs[i]);
+      const baseFlag = testArgs[i].split('=')[0];
+      if (testValueFlags.includes(baseFlag) && !testArgs[i].includes('=') && i + 1 < testArgs.length) {
+        flags.push(testArgs[++i]);
+      }
+      continue;
+    }
+    positionals.push(testArgs[i]);
+  }
+  return [...testPrefix, ...flags, ...positionals];
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const binaryPath = await resolveBinaryPath();
+  let executable = binaryPath;
+  let args = argv.slice();
+
+  if (binaryPath === 'go') {
+    const goLspPath = path.join(__dirname, '..', '..', '..', 'go_lsp');
+    executable = 'go';
+    args = resolveGoRunPaths(args, process.cwd());
+    args = ['run', './cmd/siemens-lsp', ...args];
+    process.chdir(goLspPath);
+  }
+
+  args = reorderTestArgs(args);
+
+  return new Promise((resolve) => {
+    const child = spawn(executable, args, { stdio: 'inherit' });
 
     child.on('error', (err) => {
       console.error(`plccheck: failed to start binary: ${binaryPath}`);
       console.error(err && err.stack ? err.stack : String(err));
-      process.exit(1);
+      resolve(1);
     });
 
     child.on('exit', (code, signal) => {
-      if (signal) process.kill(process.pid, signal);
-      process.exit(code == null ? 1 : code);
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      resolve(code == null ? 1 : code);
     });
-  })
-  .catch((err) => {
-    console.error(`plccheck: failed to resolve platform binary package: ${pkg}`);
-    console.error(
-      'plccheck: install failed to include optionalDependencies; falling back to direct download from npm registry.',
-    );
-    if (err && err.stack) console.error(err.stack);
-    process.exit(1);
   });
+}
+
+module.exports = {
+  isRepoDevelopmentMode,
+  reorderTestArgs,
+  resolveCoverageOutputPaths,
+  resolveGoRunPaths,
+  resolveTestPositionals,
+};
+
+if (require.main === module) {
+  main()
+    .then((code) => {
+      process.exit(code);
+    })
+    .catch((err) => {
+      console.error(`plccheck: failed to resolve platform binary package: ${pkg}`);
+      console.error(
+        'plccheck: install failed to include optionalDependencies; falling back to direct download from npm registry.',
+      );
+      if (err && err.stack) console.error(err.stack);
+      process.exit(1);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plccheck",
-  "version": "2.3.2",
+  "version": "2.5.0",
   "description": "Siemens PLC language checker + LSP CLI (SCL/ST/LAD/FBD, etc.)",
   "license": "CC-BY-NC-4.0",
   "bin": {
@@ -14,12 +14,12 @@
     "version": "node ../scripts/plccheck-npm-version-hook.mjs"
   },
   "optionalDependencies": {
-    "@danielv123/plccheck-win-x64": "2.3.2",
-    "@danielv123/plccheck-win-arm64": "2.3.2",
-    "@danielv123/plccheck-linux-x64": "2.3.2",
-    "@danielv123/plccheck-linux-arm64": "2.3.2",
-    "@danielv123/plccheck-darwin-x64": "2.3.2",
-    "@danielv123/plccheck-darwin-arm64": "2.3.2"
+    "@danielv123/plccheck-win-x64": "2.5.0",
+    "@danielv123/plccheck-win-arm64": "2.5.0",
+    "@danielv123/plccheck-linux-x64": "2.5.0",
+    "@danielv123/plccheck-linux-arm64": "2.5.0",
+    "@danielv123/plccheck-darwin-x64": "2.5.0",
+    "@danielv123/plccheck-darwin-arm64": "2.5.0"
   },
   "repository": {
     "type": "git",