@winccoa-tools-pack/npm-winccoa-ctrl-code-style 0.1.0

package/scripts/generate-changelog.mjs

@@ -0,0 +1,190 @@
+/* eslint-env node */
+/* global console, process */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function runGit(args) {
+  return execFileSync('git', args, { encoding: 'utf8' }).trim();
+}
+
+function todayIsoDate() {
+  const d = new Date();
+  const yyyy = String(d.getFullYear()).padStart(4, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}`;
+}
+
+function parseArgs(argv) {
+  const args = new Set(argv);
+  const getValue = (flag) => {
+    const idx = argv.indexOf(flag);
+    if (idx === -1) return undefined;
+    return argv[idx + 1];
+  };
+
+  return {
+    write: args.has('--write'),
+    fromTag: getValue('--from-tag'),
+    date: getValue('--date'),
+  };
+}
+
+function getStableTags() {
+  // Only stable SemVer tags like v2.3.1 (no suffix)
+  const out = runGit(['tag', '--list', 'v[0-9]*.[0-9]*.[0-9]*', '--sort=version:refname']);
+  return out ? out.split(/\r?\n/).map((t) => t.trim()).filter(Boolean) : [];
+}
+
+function getCommitSubjects(range) {
+  const args = ['log', '--no-decorate', '--pretty=%s'];
+  if (range) args.push(range);
+  const out = runGit(args);
+  if (!out) return [];
+  return out
+    .split(/\r?\n/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function isNoiseSubject(subject) {
+  if (subject.startsWith('Merge ')) return true;
+  if (subject.startsWith('chore(release):')) return true;
+  return false;
+}
+
+function categorize(subject) {
+  // Conventional commits: type(scope)!: subject
+  const match = /^(?<type>[a-z]+)(\([^\r\n()]+\))?(!)?:\s+(?<msg>.+)$/.exec(subject);
+  const type = match?.groups?.type;
+  const msg = match?.groups?.msg ?? subject;
+
+  switch (type) {
+    case 'feat':
+      return { section: 'Added', text: msg };
+    case 'fix':
+      return { section: 'Fixed', text: msg };
+    case 'perf':
+    case 'refactor':
+      return { section: 'Changed', text: msg };
+    case 'docs':
+    case 'build':
+    case 'ci':
+    case 'test':
+    case 'style':
+    case 'chore':
+    case 'revert':
+    case 'deps':
+    case 'deps-dev':
+      return { section: 'Changed', text: msg };
+    default:
+      return { section: 'Changed', text: subject };
+  }
+}
+
+function renderEntry({ version, date, itemsBySection }) {
+  const sectionsOrder = ['Added', 'Fixed', 'Changed'];
+  const lines = [];
+
+  lines.push(`## [${version}] - ${date}`);
+  lines.push('');
+
+  let any = false;
+  for (const section of sectionsOrder) {
+    const items = itemsBySection.get(section) ?? [];
+    if (items.length === 0) continue;
+    any = true;
+    lines.push(`### ${section}`);
+    lines.push('');
+    for (const item of items) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('');
+  }
+
+  if (!any) {
+    lines.push('### Changed');
+    lines.push('');
+    lines.push('- Maintenance release');
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+function insertIntoChangelog(changelogContent, entryMarkdown) {
+  const firstHeadingIdx = changelogContent.indexOf('\n## [');
+  if (firstHeadingIdx === -1) {
+    return `${changelogContent.trimEnd()}\n\n${entryMarkdown}\n`;
+  }
+
+  const before = changelogContent.slice(0, firstHeadingIdx + 1); // keep leading newline
+  const after = changelogContent.slice(firstHeadingIdx + 1);
+  return `${before}${entryMarkdown}\n\n${after}`;
+}
+
+const { write, fromTag, date: dateArg } = parseArgs(process.argv.slice(2));
+
+const repoRoot = path.resolve(process.cwd());
+const packageJsonPath = path.join(repoRoot, 'package.json');
+const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
+
+if (!fs.existsSync(packageJsonPath)) {
+  console.error(`::error::Missing package.json at ${packageJsonPath}`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(changelogPath)) {
+  console.error(`::error::Missing CHANGELOG.md at ${changelogPath}`);
+  process.exit(1);
+}
+
+const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = String(pkg.version || '').trim();
+if (!version) {
+  console.error('::error::package.json does not contain a valid "version" field');
+  process.exit(1);
+}
+
+const changelog = fs.readFileSync(changelogPath, 'utf8');
+const expectedHeadingPrefix = `## [${version}] - `;
+const alreadyExists = changelog.includes(expectedHeadingPrefix);
+
+let startTag = fromTag;
+if (!startTag) {
+  const stableTags = getStableTags().filter((t) => t !== `v${version}`);
+  startTag = stableTags.length > 0 ? stableTags[stableTags.length - 1] : undefined;
+}
+
+const range = startTag ? `${startTag}..HEAD` : undefined;
+const subjects = getCommitSubjects(range)
+  .filter((s) => !isNoiseSubject(s));
+
+const itemsBySection = new Map([
+  ['Added', []],
+  ['Fixed', []],
+  ['Changed', []],
+]);
+
+for (const subject of subjects) {
+  const { section, text } = categorize(subject);
+  itemsBySection.get(section)?.push(text);
+}
+
+const entry = renderEntry({ version, date: dateArg ?? todayIsoDate(), itemsBySection });
+
+process.stdout.write(entry + '\n');
+
+if (!write) {
+  process.exit(0);
+}
+
+if (alreadyExists) {
+  console.error(`CHANGELOG already contains heading for v${version}; skipping write.`);
+  process.exit(0);
+}
+
+const updated = insertIntoChangelog(changelog, entry);
+fs.writeFileSync(changelogPath, updated, 'utf8');
+console.error(`✅ Inserted changelog entry for v${version} into CHANGELOG.md`);

package/scripts/register-stylecheck-projects.ps1

@@ -0,0 +1,92 @@
+<#
+.SYNOPSIS
+  Register StyleCheck (non-runnable) and a worker project (runnable) with StyleCheck as sub-project.
+
+.DESCRIPTION
+  Uses @winccoa-tools-pack/npm-winccoa-register-project locally or in CI.
+  Prefer this on Windows; the .sh script is for Git Bash / Linux / CI containers.
+
+.EXAMPLE
+  ./scripts/register-stylecheck-projects.ps1 -ProjectPath ./src/Squirt -Version 3.21
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [string] $ProjectPath,
+
+    [Parameter(Mandatory = $true)]
+    [Alias('v')]
+    [string] $Version,
+
+    [string] $Langs = 'en_US.utf8',
+
+    [string] $StyleCheckPath = '',
+
+    [string] $RegisterCli = '',
+
+    [switch] $DryRun
+)
+
+$ErrorActionPreference = 'Stop'
+$PkgRoot = Split-Path -Parent $PSScriptRoot
+if (-not $StyleCheckPath) {
+    $StyleCheckPath = Join-Path $PkgRoot 'winccoa\StyleCheck'
+}
+
+$ProjectPath = (Resolve-Path -LiteralPath $ProjectPath).Path
+$StyleCheckPath = (Resolve-Path -LiteralPath $StyleCheckPath).Path
+
+function Find-RegisterCli {
+    if ($RegisterCli -and (Test-Path -LiteralPath $RegisterCli)) {
+        return (Resolve-Path -LiteralPath $RegisterCli).Path
+    }
+    $candidates = @(
+        (Join-Path $PkgRoot 'node_modules\@winccoa-tools-pack\npm-winccoa-register-project\dist\cjs\cli.js'),
+        (Join-Path $PkgRoot '..\npm-winccoa-register-project\dist\cjs\cli.js'),
+        (Join-Path $PkgRoot '..\npm-winccoa-register-project\dist\src\cli.js')
+    )
+    foreach ($c in $candidates) {
+        if (Test-Path -LiteralPath $c) { return (Resolve-Path -LiteralPath $c).Path }
+    }
+    $cmd = Get-Command npm-winccoa-register -ErrorAction SilentlyContinue
+    if ($cmd) { return $cmd.Source }
+    throw 'Could not find npm-winccoa-register-project CLI. Install the package or pass -RegisterCli.'
+}
+
+function Invoke-Register {
+    param([string[]] $Args)
+    $cli = Find-RegisterCli
+    Write-Host "register: $cli $($Args -join ' ')"
+    if ($DryRun) { return }
+    if ($cli -like '*.js') {
+        & node $cli @Args
+    } else {
+        & $cli @Args
+    }
+    if ($LASTEXITCODE -ne 0) {
+        throw "Registration failed with exit code $LASTEXITCODE"
+    }
+}
+
+Write-Host "StyleCheck (non-runnable): $StyleCheckPath"
+Write-Host "Worker project (runnable): $ProjectPath"
+Write-Host "WinCC OA version: $Version"
+Write-Host "Langs: $Langs"
+
+Invoke-Register -Args @(
+    '--project-path', $StyleCheckPath,
+    '--runnable', 'false',
+    '--wincc-oa-version', $Version
+)
+
+Invoke-Register -Args @(
+    '--project-path', $ProjectPath,
+    '--runnable', 'true',
+    '--langs', $Langs,
+    '--wincc-oa-version', $Version,
+    '--sub-project', $StyleCheckPath
+)
+
+Write-Host "Done."
+Write-Host "Worker config: $(Join-Path $ProjectPath 'config\config')"
+Write-Host "Next: winccoa-ctrl-style check `"$ProjectPath`" -v $Version --no-register"

package/scripts/register-stylecheck-projects.sh

@@ -0,0 +1,193 @@
+#!/usr/bin/env bash
+# register-stylecheck-projects.sh
+#
+# Register StyleCheck (non-runnable) and a worker/source project (runnable)
+# with StyleCheck as --sub-project, using npm-winccoa-register-project.
+#
+# Usable locally and in CI.
+#
+# Example:
+#   ./scripts/register-stylecheck-projects.sh \
+#     --project-path ./src/Squirt \
+#     --version 3.21 \
+#     --langs en_US.utf8
+#
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PKG_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+PROJECT_PATH=""
+VERSION=""
+LANGS="en_US.utf8"
+STYLE_CHECK_PATH="${PKG_ROOT}/winccoa/StyleCheck"
+REGISTER_CLI=""
+DRY_RUN=0
+
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") --project-path <workerProject> [options]
+
+Register:
+  1) StyleCheck as non-runnable WinCC OA project
+  2) Worker project as runnable with --sub-project StyleCheck
+
+Options:
+  --project-path <path>       Runnable worker/source project (required)
+  -v, --version <ver>         WinCC OA version (e.g. 3.21)
+  --langs <csv>               Languages (default: en_US.utf8)
+  --style-check-path <path>   StyleCheck path (default: package winccoa/StyleCheck)
+  --register-cli <path>       Path to npm-winccoa-register CLI js entry
+  --dry-run                   Print commands only
+  -h, --help                  Show help
+
+Environment:
+  WINCCOA_VERSION             Fallback for --version
+  WINCCOA_REGISTER_CLI        Fallback for --register-cli
+
+After success, run style check with worker config, e.g.:
+  WCCOActrl -config <worker>/config/config -n -log +stderr astyle.ctl <source>
+  # or:
+  winccoa-ctrl-style check <worker> -v <ver> --no-register
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project-path)
+      PROJECT_PATH="${2:-}"; shift 2 ;;
+    -v|--version)
+      VERSION="${2:-}"; shift 2 ;;
+    --langs)
+      LANGS="${2:-}"; shift 2 ;;
+    --style-check-path)
+      STYLE_CHECK_PATH="${2:-}"; shift 2 ;;
+    --register-cli)
+      REGISTER_CLI="${2:-}"; shift 2 ;;
+    --dry-run)
+      DRY_RUN=1; shift ;;
+    -h|--help)
+      usage; exit 0 ;;
+    *)
+      echo "Unknown option: $1" >&2
+      usage >&2
+      exit 1 ;;
+  esac
+done
+
+VERSION="${VERSION:-${WINCCOA_VERSION:-}}"
+REGISTER_CLI="${REGISTER_CLI:-${WINCCOA_REGISTER_CLI:-}}"
+
+if [[ -z "${PROJECT_PATH}" ]]; then
+  echo "Error: --project-path is required" >&2
+  usage >&2
+  exit 1
+fi
+
+if [[ -z "${VERSION}" ]]; then
+  echo "Error: --version (or WINCCOA_VERSION) is required" >&2
+  exit 1
+fi
+
+# Resolve absolute paths when possible
+if command -v realpath >/dev/null 2>&1; then
+  PROJECT_PATH="$(realpath "${PROJECT_PATH}")"
+  STYLE_CHECK_PATH="$(realpath "${STYLE_CHECK_PATH}")"
+else
+  PROJECT_PATH="$(cd "${PROJECT_PATH}" && pwd)"
+  STYLE_CHECK_PATH="$(cd "${STYLE_CHECK_PATH}" && pwd)"
+fi
+
+if [[ ! -d "${PROJECT_PATH}" ]]; then
+  echo "Error: project path does not exist: ${PROJECT_PATH}" >&2
+  exit 1
+fi
+if [[ ! -d "${STYLE_CHECK_PATH}" ]]; then
+  echo "Error: StyleCheck path does not exist: ${STYLE_CHECK_PATH}" >&2
+  exit 1
+fi
+
+find_register_cli() {
+  if [[ -n "${REGISTER_CLI}" && -f "${REGISTER_CLI}" ]]; then
+    echo "${REGISTER_CLI}"
+    return 0
+  fi
+
+  local candidates=(
+    "${PKG_ROOT}/node_modules/@winccoa-tools-pack/npm-winccoa-register-project/dist/cjs/cli.js"
+    "${PKG_ROOT}/../npm-winccoa-register-project/dist/cjs/cli.js"
+    "${PKG_ROOT}/../npm-winccoa-register-project/dist/src/cli.js"
+  )
+  local c
+  for c in "${candidates[@]}"; do
+    if [[ -f "${c}" ]]; then
+      echo "${c}"
+      return 0
+    fi
+  done
+
+  if command -v npm-winccoa-register >/dev/null 2>&1; then
+    echo "npm-winccoa-register"
+    return 0
+  fi
+
+  return 1
+}
+
+run_cmd() {
+  if [[ "${DRY_RUN}" -eq 1 ]]; then
+    printf '+'
+    printf ' %q' "$@"
+    printf '\n'
+    return 0
+  fi
+  "$@"
+}
+
+REGISTER_BIN="$(find_register_cli)" || {
+  echo "Error: could not find npm-winccoa-register-project CLI." >&2
+  echo "Install @winccoa-tools-pack/npm-winccoa-register-project or pass --register-cli." >&2
+  exit 1
+}
+
+echo "StyleCheck (non-runnable): ${STYLE_CHECK_PATH}"
+echo "Worker project (runnable): ${PROJECT_PATH}"
+echo "WinCC OA version: ${VERSION}"
+echo "Langs: ${LANGS}"
+echo "Register CLI: ${REGISTER_BIN}"
+
+# 1) StyleCheck non-runnable
+if [[ "${REGISTER_BIN}" == *.js ]]; then
+  run_cmd node "${REGISTER_BIN}" \
+    --project-path "${STYLE_CHECK_PATH}" \
+    --runnable false \
+    --wincc-oa-version "${VERSION}"
+else
+  run_cmd "${REGISTER_BIN}" \
+    --project-path "${STYLE_CHECK_PATH}" \
+    --runnable false \
+    --wincc-oa-version "${VERSION}"
+fi
+
+# 2) Worker runnable + StyleCheck sub-project
+# Note: register-project only writes config when missing. For a forced rewrite
+# use: winccoa-ctrl-style register <projectPath> -v <ver>
+if [[ "${REGISTER_BIN}" == *.js ]]; then
+  run_cmd node "${REGISTER_BIN}" \
+    --project-path "${PROJECT_PATH}" \
+    --runnable true \
+    --langs "${LANGS}" \
+    --wincc-oa-version "${VERSION}" \
+    --sub-project "${STYLE_CHECK_PATH}"
+else
+  run_cmd "${REGISTER_BIN}" \
+    --project-path "${PROJECT_PATH}" \
+    --runnable true \
+    --langs "${LANGS}" \
+    --wincc-oa-version "${VERSION}" \
+    --sub-project "${STYLE_CHECK_PATH}"
+fi
+
+echo "Done."
+echo "Worker config: ${PROJECT_PATH}/config/config"
+echo "Next: winccoa-ctrl-style check \"${PROJECT_PATH}\" -v ${VERSION} --no-register"

package/scripts/run-node-tests.ts

@@ -0,0 +1,74 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function collectTestFiles(rootDir: string): string[] {
+    const out: string[] = [];
+    const stack: string[] = [rootDir];
+
+    while (stack.length > 0) {
+        const dir = stack.pop()!;
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+
+            if (entry.isFile() && entry.name.endsWith('.test.ts')) {
+                out.push(fullPath);
+            }
+        }
+    }
+
+    return out.sort();
+}
+
+// Collect CLI args but ignore option-like args (starting with '-')
+const rawArgs = process.argv.slice(2);
+const targets = rawArgs.filter((a) => !a.startsWith('-'));
+if (targets.length === 0) {
+    console.error('Usage: node --import tsx scripts/run-node-tests.ts <file|dir> [file|dir...]');
+    process.exit(2);
+}
+
+const cwd = process.cwd();
+const files = targets.flatMap((t) => {
+    const resolved = path.resolve(cwd, t);
+    try {
+        const stat = fs.statSync(resolved);
+        if (stat.isFile() && resolved.endsWith('.test.ts')) {
+            return [resolved];
+        }
+        if (stat.isDirectory()) {
+            return collectTestFiles(resolved);
+        }
+    } catch {
+        // ignore missing targets
+    }
+    return [] as string[];
+});
+
+if (files.length === 0) {
+    console.error(`No '*.test.ts' files found under: ${targets.join(', ')}`);
+    process.exit(1);
+}
+
+// Run tests one by one to better isolate failures
+// Integration tests may leave resources hanging that interfere with subsequent tests
+let failed = false;
+for (const file of files) {
+    const args = ['--import', 'tsx', '--test', '--test-force-exit', file];
+    const result = spawnSync(process.execPath, args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+        failed = true;
+    }
+}
+process.exit(failed ? 1 : 0);

package/scripts/wait-for-winccoa.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env sh
+# Wait for WinCC OA in container to be ready.
+# Usage: wait-for-winccoa.sh <container-name> <max-retries>
+
+container="$1"
+max_retries="${2:-60}"
+delay=2
+
+if [ -z "$container" ]; then
+  echo "Usage: $0 <container-name> [max-retries]"
+  exit 2
+fi
+
+echo "Waiting for WinCC OA in container '$container' (max $max_retries attempts)..."
+i=0
+while [ $i -lt $max_retries ]; do
+  i=$((i+1))
+  docker exec "$container" sh -c "if [ -x /opt/WinCC_OA/bin/winccoa ]; then echo ready; exit 0; else exit 1; fi" >/dev/null 2>&1 && {
+    echo "Ready after $i attempts"
+    exit 0
+  }
+  sleep $delay
+done
+
+echo "Timed out waiting for WinCC OA in container '$container'"
+exit 1