api-tuner 0.2.5 → 0.3.0

package/bin/tuner.sh

@@ -1,95 +1,16 @@
-#!/bin/bash
-SCRIPT_PATH=$(dirname "$(readlink -f "$0")")
+#!/usr/bin/env bash
 
-eye="swipl -x ${SCRIPT_PATH}/../eye/lib/eye.pvm --"
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
-# function prints version
-function version() {
-  # read from ./package.json
-  API_TUNER_VERSION=$(cat "${SCRIPT_PATH}"/../package.json | grep version | head -1 | awk -F: '{ print $2 }' | sed 's/[",]//g' | tr -d '[[:space:]]')
-  echo "API-TUNER v${API_TUNER_VERSION}"
-  $eye --version
-}
+# find JS entrypoint
+tuner="$SCRIPT_DIR/index.js"
 
- function usage() {
-   echo "Usage: api-tuner [options] <path>..."
-   echo ""
-   echo "Options:"
-   echo "  --lib <path>       Specify rules to include in all tests. Can be used multiple times. Make sure to surround globs in quotes to prevent expansion."
-   echo "  --silent           Less output"
-   echo "  --debug            Enable debug output"
-   echo "  --raw              Output raw results from eye"
-   echo "  --base-iri <iri>   Specify the base IRI for parsing the test case files"
-   echo "  --version          Show version information"
-   echo "  --help             Show this help message"
- }
-
-SILENT=false
-BASE_IRI=""
-DEBUG=false
-SUMMARY="node ${SCRIPT_PATH}/../lib/summarise-results.js --summary"
-PATHS=()
-LIBS=()
-# USAGE: ./tuner.sh --debug --version ...paths
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --debug)
-      DEBUG=true
-      shift
-      ;;
-    --silent)
-      SILENT=true
-      shift
-      ;;
-    --raw)
-      SUMMARY="node ${SCRIPT_PATH}/../lib/summarise-results.js"
-      shift
-      ;;
-    --base-iri)
-      BASE_IRI="$2"
-      shift
-      shift
-      ;;
-    --version)
-      version
-      exit 0
-      ;;
-    --help)
-      usage
-      exit 0
-      ;;
-    --lib)
-      LIBS+=("$2")
-      shift
-      shift
-      ;;
-    *)
-      PATHS+=("$1")
-      shift
-      ;;
-  esac
-done
-
-# if no paths
-if [ ${#PATHS[@]} -eq 0 ]; then
-  usage
-  exit 1
-fi
-
-ARGS="--quiet --nope --pass"
-
-if [ "$DEBUG" = true ]; then
-  ARGS="$ARGS ${SCRIPT_PATH}/../logging/debug.n3"
-fi
-
-if [ "$SILENT" != true ]; then
-  ARGS="$ARGS ${SCRIPT_PATH}/../logging/info.n3"
+# if tsx exists in path
+if command -v tsx > /dev/null 2>&1
+then
+  # use tsx
+  node --import tsx --no-warnings "$tuner" "$@"
+else
+  # use plain node
+  node "$tuner" "$@"
 fi
-
-set -o pipefail
-for path in "${PATHS[@]}"; do
-  (
-    node "${SCRIPT_PATH}/../lib/parse-test-case.js" --base-iri "$BASE_IRI" -- "${path}" \
-      | $eye $ARGS "${SCRIPT_PATH}"/../rules/*.n3 ${LIBS[@]:+${LIBS[*]}} -
-  ) ;
-done | $SUMMARY

package/index.js

@@ -0,0 +1,107 @@
+import * as url from 'node:url';
+import * as childProcess from 'node:child_process';
+import { PassThrough } from 'node:stream';
+import { resolve } from 'node:path';
+import { program } from 'commander';
+import getStream from 'get-stream';
+import packageJson from './package.json' with { type: 'json' };
+import parseTestCase from './lib/parse-test-case.js';
+import summariseResults from './lib/summarise-results.js';
+const eyePvmPath = url.fileURLToPath(new URL('eye/lib/eye.pvm', import.meta.url));
+program
+    .name('api-tuner')
+    .option('--lib <lib>', 'Specify rules to include in all tests. Can be used multiple times. Make sure to surround globs in quotes to prevent expansion.')
+    .option('--silent', 'Less output', false)
+    .option('--debug', 'Enable debug output', false)
+    .option('--raw', 'Output raw results from eyes')
+    .requiredOption('--base-iri <baseIri>', 'Specify the base IRI for parsing the test case files')
+    .option('--version', 'Show version information')
+    .argument('[paths...]', 'Paths to test files')
+    .parse();
+const options = program.opts();
+if (options.version) {
+    process.stdout.write(`API-TUNER ${packageJson.version}\n`);
+    childProcess.execSync(`swipl -x ${eyePvmPath} -- --version`, { stdio: 'inherit' });
+    process.exit();
+}
+if (!program.args.length) {
+    program.help();
+    process.exit();
+}
+const eyeArgs = [
+    '--quiet',
+    '--nope',
+    '--pass',
+];
+if (options.debug) {
+    const debugN3Path = url.fileURLToPath(new URL('logging/debug.n3', import.meta.url));
+    eyeArgs.push(debugN3Path);
+}
+if (!options.silent) {
+    const infoN3Path = url.fileURLToPath(new URL('logging/info.n3', import.meta.url));
+    eyeArgs.push(infoN3Path);
+}
+const rulesPath = url.fileURLToPath(new URL('rules/*.n3', import.meta.url));
+const levelIcon = {
+    INFO: 'ℹ️',
+    DEBUG: '🐞',
+    'Failed assertion': '❌',
+};
+async function processPath(path) {
+    return new Promise(resolve => {
+        const testCaseStream = parseTestCase(path, options.baseIri);
+        const eyeProc = childProcess.spawn('swipl', [
+            '-x',
+            eyePvmPath,
+            '--',
+            ...eyeArgs,
+            rulesPath,
+            '-',
+        ], {
+            shell: true,
+        });
+        testCaseStream.pipe(eyeProc.stdin);
+        const stdout = new PassThrough();
+        const stderr = new PassThrough();
+        eyeProc.on('exit', (code) => {
+            resolve({
+                stdout,
+                stderr,
+                success: code === 0,
+            });
+        });
+        eyeProc.stdout.pipe(stdout);
+        eyeProc.stderr.pipe(stderr);
+    });
+}
+const testSuites = program.args.map(async (path) => {
+    const absolutePath = resolve(process.cwd(), path);
+    const result = await processPath(path);
+    const suiteHeader = options.silent ? '' : `\n⚡️ SUITE   <file://${absolutePath}>\n`;
+    const summaryPassThrough = new PassThrough();
+    const rawPassThrough = new PassThrough();
+    result.stdout.pipe(summaryPassThrough);
+    result.stdout.pipe(rawPassThrough);
+    const validationResult = await summariseResults(summaryPassThrough);
+    if (options.raw) {
+        process.stdout.write(suiteHeader + await getStream(rawPassThrough));
+    }
+    else {
+        const stderr = await getStream(result.stderr);
+        process.stderr.write(suiteHeader + stderr.replace(/"(\w+)" TRACE "(.*)"/g, (_, level, text) => {
+            return `${levelIcon[level]} ${text}`;
+        }));
+    }
+    return {
+        summary: `\n🔎 SUITE   <file://${absolutePath}>\n${validationResult.summary}`,
+        success: result.success && validationResult.success,
+    };
+});
+Promise.all(testSuites).then((results) => {
+    const summary = results.map(result => result.summary).join('\n');
+    if (!options.raw) {
+        process.stdout.write(summary + '\n');
+    }
+    // exit code equals number of failed tests
+    process.exit(results.filter(result => !result.success).length);
+});

package/lib/merge-curl-output.js

@@ -1,60 +1,54 @@
-import * as fs from 'node:fs/promises'
-import { createReadStream } from 'node:fs'
-import jsonld from 'jsonld'
-import rdf from '@zazuko/env-node'
-import { write } from '@jeswr/pretty-turtle'
-
+import * as fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+// eslint-disable-next-line import/default
+import jsonld from 'jsonld';
+import rdf from '@zazuko/env-node';
+import { write } from '@jeswr/pretty-turtle';
 const ns = rdf.namespace('https://api-tuner.described.at/');
-
 (async () => {
-  const bodyPath = process.argv[2]
-
-  const curlJsonPath = `${bodyPath}.curl.json`
-  const { response: responseJson, headers: headersJson } = JSON.parse((await fs.readFile(curlJsonPath)).toString())
-  /**
-   * @type {Record<string, string | number | null>}
-   */
-  const curlJsonLd = Object.assign({
-    '@context': {
-      '@vocab': ns().value,
-    },
-  }, responseJson)
-
-  /**
-   * @type {import('@rdfjs/types').Quad[]}
-   */
-  const responseQuads = await jsonld.toRDF(curlJsonLd)
-  const response = rdf.clownface({
-    dataset: rdf.dataset(responseQuads),
-  }).has(ns.exitcode).addOut(rdf.ns.rdf.type, ns.Response)
-
-  let contentType
-  if (typeof responseJson.content_type === 'string') {
-    contentType = responseJson.content_type.substring(0, responseJson.content_type.indexOf(';')) || responseJson.content_type
-  }
-  let parser
-  if (contentType) {
-    parser = rdf.formats.parsers.get(contentType)
-  }
-  if (parser) {
-    const bodyGraph = rdf.blankNode()
-    const bodyStream = parser.import(createReadStream(bodyPath))
-    for await (const quad of bodyStream) {
-      response.dataset.add(rdf.quad(quad.subject, quad.predicate, quad.object, bodyGraph))
+    const bodyPath = process.argv[2];
+    const curlJsonPath = `${bodyPath}.curl.json`;
+    const { response: responseJson, headers: headersJson } = JSON.parse((await fs.readFile(curlJsonPath)).toString());
+    /**
+     * @type {Record<string, string | number | null>}
+     */
+    const curlJsonLd = Object.assign({
+        '@context': {
+            '@vocab': ns().value,
+        },
+    }, responseJson);
+    /**
+     * @type {import('@rdfjs/types').Quad[]}
+     */
+    const responseQuads = await jsonld.toRDF(curlJsonLd);
+    const response = rdf.clownface({
+        dataset: rdf.dataset(responseQuads),
+    }).has(ns.exitcode).addOut(rdf.ns.rdf.type, ns.Response);
+    let contentType;
+    if (typeof responseJson.content_type === 'string') {
+        contentType = responseJson.content_type.substring(0, responseJson.content_type.indexOf(';')) || responseJson.content_type;
     }
-    response.addOut(ns.body, bodyGraph)
-  } else {
-    const body = await fs.readFile(bodyPath, 'utf-8')
-    if (body) {
-      response.addOut(ns.body, body)
+    let parser;
+    if (contentType) {
+        parser = rdf.formats.parsers.get(contentType);
     }
-  }
-
-  const headers = Object.entries(headersJson).flatMap(([header, values]) =>
-    values.map(value => response.blankNode().addOut(ns.name, header).addOut(ns.value, value)))
-  response.addOut(ns.headers, headers)
-
-  process.stdout.write(await write([...response.dataset], {
-    format: 'text/n3',
-  }))
-})()
+    if (parser) {
+        const bodyGraph = rdf.blankNode();
+        const bodyStream = parser.import(createReadStream(bodyPath));
+        for await (const quad of bodyStream) {
+            response.dataset.add(rdf.quad(quad.subject, quad.predicate, quad.object, bodyGraph));
+        }
+        response.addOut(ns.body, bodyGraph);
+    }
+    else {
+        const body = await fs.readFile(bodyPath, 'utf-8');
+        if (body) {
+            response.addOut(ns.body, body);
+        }
+    }
+    const headers = Object.entries(headersJson).flatMap(([header, values]) => values.map(value => response.blankNode().addOut(ns('name'), header).addOut(ns.value, value)));
+    response.addOut(ns.headers, headers);
+    process.stdout.write(await write([...response.dataset], {
+        format: 'text/n3',
+    }));
+})();

package/lib/merge-curl-output.ts

@@ -0,0 +1,72 @@
+import * as fs from 'node:fs/promises'
+import { createReadStream } from 'node:fs'
+// eslint-disable-next-line import/default
+import jsonld from 'jsonld'
+import rdf from '@zazuko/env-node'
+import { write } from '@jeswr/pretty-turtle'
+import type { DatasetCore, Quad } from '@rdfjs/types'
+
+declare module '@rdfjs/types' {
+  interface Stream extends AsyncIterable<Quad>{
+  }
+}
+
+interface CurlFile {
+  response: Record<string, string | number | null>
+  headers: Record<string, string[]>
+}
+
+const ns = rdf.namespace('https://api-tuner.described.at/');
+
+(async () => {
+  const bodyPath = process.argv[2]
+
+  const curlJsonPath = `${bodyPath}.curl.json`
+  const { response: responseJson, headers: headersJson } = JSON.parse((await fs.readFile(curlJsonPath)).toString()) as CurlFile
+  /**
+   * @type {Record<string, string | number | null>}
+   */
+  const curlJsonLd = Object.assign({
+    '@context': {
+      '@vocab': ns().value,
+    },
+  }, responseJson)
+
+  /**
+   * @type {import('@rdfjs/types').Quad[]}
+   */
+  const responseQuads = await jsonld.toRDF(curlJsonLd) as DatasetCore
+  const response = rdf.clownface({
+    dataset: rdf.dataset(responseQuads),
+  }).has(ns.exitcode).addOut(rdf.ns.rdf.type, ns.Response)
+
+  let contentType
+  if (typeof responseJson.content_type === 'string') {
+    contentType = responseJson.content_type.substring(0, responseJson.content_type.indexOf(';')) || responseJson.content_type
+  }
+  let parser
+  if (contentType) {
+    parser = rdf.formats.parsers.get(contentType)
+  }
+  if (parser) {
+    const bodyGraph = rdf.blankNode()
+    const bodyStream = parser.import(createReadStream(bodyPath))
+    for await (const quad of bodyStream) {
+      response.dataset.add(rdf.quad(quad.subject, quad.predicate, quad.object, bodyGraph))
+    }
+    response.addOut(ns.body, bodyGraph)
+  } else {
+    const body = await fs.readFile(bodyPath, 'utf-8')
+    if (body) {
+      response.addOut(ns.body, body)
+    }
+  }
+
+  const headers = Object.entries(headersJson).flatMap(([header, values]) =>
+    values.map(value => response.blankNode().addOut(ns('name'), header).addOut(ns.value, value)))
+  response.addOut(ns.headers, headers)
+
+  process.stdout.write(await write([...response.dataset], {
+    format: 'text/n3',
+  }))
+})()

package/lib/parse-test-case.js

@@ -1,39 +1,20 @@
-import * as url from 'node:url'
-import { createReadStream } from 'node:fs'
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-import replaceStream from 'replacestream'
-import isAbsoluteUrl from 'is-absolute-url'
-import StreamConcat from 'stream-concat'
-
-const argv = yargs(hideBin(process.argv)).argv
-
-const baseIri = argv['base-iri'] || 'http://example.org/'
-const testCases = argv._
-
-function replacer(fileUrl) {
-  return (_, match) => {
-    if (match.startsWith('#')) {
-      return `<${fileUrl}${match}>`
+import * as url from 'node:url';
+import { createReadStream } from 'node:fs';
+import replaceStream from 'replacestream';
+import isAbsoluteUrl from 'is-absolute-url';
+export default function (testCase, baseIri) {
+    function replacer(fileUrl) {
+        return (_, match) => {
+            if (match.startsWith('#')) {
+                return `<${fileUrl}${match}>`;
+            }
+            if (isAbsoluteUrl(match)) {
+                return `<${match}>`;
+            }
+            return `<${baseIri}${match}>`;
+        };
     }
-
-    if (isAbsoluteUrl(match)) {
-      return `<${match}>`
-    }
-
-    return `<${baseIri}${match}>`
-  }
-}
-
-let fileIndex = 0
-function nextStream() {
-  if (fileIndex === testCases.length) {
-    return null
-  }
-  const testCase = testCases[fileIndex++]
-  const testCaseUrl = url.pathToFileURL(testCase).toString()
-  return createReadStream(testCase)
-    .pipe(replaceStream(/<([^>]*)>(?=([^"\\]*(\\.|"([^"\\]*\\.)*[^"\\]*"))*[^"]*$)/g, replacer(testCaseUrl)))
+    const testCaseUrl = url.pathToFileURL(testCase).toString();
+    return createReadStream(testCase)
+        .pipe(replaceStream(/<([^>]*)>(?=([^"\\]*(\\.|"([^"\\]*\\.)*[^"\\]*"))*[^"]*$)/g, replacer(testCaseUrl)));
 }
-
-new StreamConcat(nextStream).pipe(process.stdout)

package/lib/parse-test-case.ts

@@ -0,0 +1,25 @@
+import * as url from 'node:url'
+import { createReadStream } from 'node:fs'
+import type { Readable } from 'node:stream'
+import replaceStream from 'replacestream'
+import isAbsoluteUrl from 'is-absolute-url'
+
+export default function (testCase: string, baseIri: string): Readable {
+  function replacer(fileUrl: string) {
+    return (_: unknown, match: string) => {
+      if (match.startsWith('#')) {
+        return `<${fileUrl}${match}>`
+      }
+
+      if (isAbsoluteUrl(match)) {
+        return `<${match}>`
+      }
+
+      return `<${baseIri}${match}>`
+    }
+  }
+
+  const testCaseUrl = url.pathToFileURL(testCase).toString()
+  return createReadStream(testCase)
+    .pipe(replaceStream(/<([^>]*)>(?=([^"\\]*(\\.|"([^"\\]*\\.)*[^"\\]*"))*[^"]*$)/g, replacer(testCaseUrl)))
+}

package/lib/summarise-results.js

@@ -1,65 +1,33 @@
-import { PassThrough } from 'node:stream'
-import SHACLValidator from 'rdf-validate-shacl'
-import rdf from '@zazuko/env-node'
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-
-const argv = yargs(hideBin(process.argv)).argv
-
-const shapesTtl = new URL('./shapes.ttl', import.meta.url)
-
-;(async () => {
-  const shapes = await rdf.dataset().import(rdf.fromFile(shapesTtl))
-  const validator = new SHACLValidator(shapes, {
-    factory: rdf,
-  })
-
-  const dataPassThrough = new PassThrough()
-  process.stdin.pipe(dataPassThrough)
-
-  if (!argv.summary) {
-    process.stdin.pipe(process.stdout)
-  }
-
-  const data = await rdf.dataset().import(rdf.formats.parsers.import('text/n3', dataPassThrough, {
-    format: 'n3',
-  }))
-
-  const validationReport = validator.validate(data)
-
-  if (argv.summary) {
-    const resultMap = rdf.clownface({ dataset: data })
-      .has(rdf.ns.rdf.type, rdf.ns.earl.TestCase)
-      .toArray()
-      .reduce((map, testCase) => {
-        const { pathname } = new URL(testCase)
-
-        const testCases = map.get(pathname) || []
-        testCases.push(testCase)
-
-        return map.set(pathname, testCases)
-      }, new Map())
-
-    for (const [pathname, testCases] of resultMap.entries()) {
-      const summary = ['']
-      summary.push(`🔎 SUITE  <file://${pathname}>`)
-
-      for (const testCase of testCases) {
-        const { hash } = new URL(testCase.value)
-        const result = validationReport.results.find(result => result.focusNode.equals(testCase.term))
-        const label = testCase.out(rdf.ns.rdfs.label).value
-        const resultLine = label ? `${label} (<${hash}>)` : `<${hash}>`
-
-        if (result?.severity.equals(rdf.ns.sh.Violation)) {
-          summary.push(`❌  FAIL   ${resultLine}`)
-        } else {
-          summary.push(`✅  PASS   ${resultLine}`)
+import SHACLValidator from 'rdf-validate-shacl';
+import rdf from '@zazuko/env-node';
+const shapesTtl = new URL('./shapes.ttl', import.meta.url);
+export default async (resultStream) => {
+    const shapes = await rdf.dataset().import(rdf.fromFile(shapesTtl));
+    const validator = new SHACLValidator(shapes, {
+        factory: rdf,
+    });
+    const data = await rdf.dataset().import(rdf.formats.parsers.import('text/n3', resultStream, {
+        format: 'n3',
+    }));
+    const validationReport = validator.validate(data);
+    const testCases = rdf.clownface({ dataset: data })
+        .has(rdf.ns.rdf.type, rdf.ns.earl.TestCase)
+        .toArray();
+    const summary = [];
+    for (const testCase of testCases) {
+        const { hash } = new URL(testCase.value);
+        const result = validationReport.results.find(result => testCase.term.equals(result.focusNode));
+        const label = testCase.out(rdf.ns.rdfs.label).value;
+        const resultLine = label ? `${label} (<${hash}>)` : `<${hash}>`;
+        if (rdf.ns.sh.Violation.equals(result?.severity)) {
+            summary.push(`❌  FAIL   ${resultLine}`);
+        }
+        else {
+            summary.push(`✅  PASS   ${resultLine}`);
         }
-      }
-
-      process.stderr.write(summary.join('\n') + '\n')
     }
-  }
-
-  process.exit(validationReport.conforms ? 0 : 1)
-})()
+    return {
+        success: validationReport.conforms,
+        summary: summary.join('\n'),
+    };
+};

package/lib/summarise-results.ts

@@ -0,0 +1,46 @@
+import type { Readable } from 'node:stream'
+import SHACLValidator from 'rdf-validate-shacl'
+import rdf from '@zazuko/env-node'
+
+const shapesTtl = new URL('./shapes.ttl', import.meta.url)
+
+interface Result {
+  summary: string
+  success: boolean
+}
+
+export default async (resultStream: Readable): Promise<Result> => {
+  const shapes = await rdf.dataset().import(rdf.fromFile(shapesTtl))
+  const validator = new SHACLValidator(shapes, {
+    factory: rdf,
+  })
+
+  const data = await rdf.dataset().import(rdf.formats.parsers.import('text/n3', resultStream, {
+    format: 'n3',
+  })!)
+
+  const validationReport = validator.validate(data)
+
+  const testCases = rdf.clownface({ dataset: data })
+    .has(rdf.ns.rdf.type, rdf.ns.earl.TestCase)
+    .toArray()
+
+  const summary = []
+  for (const testCase of testCases) {
+    const { hash } = new URL(testCase.value)
+    const result = validationReport.results.find(result => testCase.term.equals(result.focusNode))
+    const label = testCase.out(rdf.ns.rdfs.label).value
+    const resultLine = label ? `${label} (<${hash}>)` : `<${hash}>`
+
+    if (rdf.ns.sh.Violation.equals(result?.severity)) {
+      summary.push(`❌  FAIL   ${resultLine}`)
+    } else {
+      summary.push(`✅  PASS   ${resultLine}`)
+    }
+  }
+
+  return {
+    success: validationReport.conforms,
+    summary: summary.join('\n'),
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-tuner",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "main": "index.js",
   "type": "module",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "lint": "eslint . --quiet --ignore-path .gitignore",
     "pretest": "docker compose up -d",
     "test": "./bin/tuner.sh tests/*.n3 tests/**/*.n3 --base-iri http://localhost:1080/",
+    "prepack": "tsc",
     "release": "changeset publish"
   },
   "files": [
@@ -26,21 +27,29 @@
     "@changesets/cli": "^2.27.12",
     "@jeswr/pretty-turtle": "^1.5.0",
     "@zazuko/env-node": "^2.1.4",
+    "commander": "^13.1.0",
+    "get-stream": "^9.0.1",
     "is-absolute-url": "^4.0.1",
     "jsonld": "^8.3.3",
     "rdf-validate-shacl": "^0.5.6",
-    "replacestream": "^4.0.3",
-    "stream-concat": "^2.0.0",
-    "yargs": "^17.7.2"
+    "replacestream": "^4.0.3"
   },
   "devDependencies": {
     "@rdfjs/types": "^1",
     "@tpluscode/eslint-config": "^0.5.0",
     "@types/jsonld": "^1.5.15",
+    "@types/n3": "^1.24.2",
     "@types/rdf-validate-shacl": "^0.4.9",
+    "@types/replacestream": "^4.0.4",
     "@types/yargs": "^17.0.33",
+    "@typescript-eslint/eslint-plugin": "^7",
+    "@typescript-eslint/parser": "^7",
+    "eslint": "^8.57.1",
+    "eslint-import-resolver-typescript": "^4.3.4",
     "husky": "^9.1.7",
-    "lint-staged": "^15.4.3"
+    "lint-staged": "^15.4.3",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
   },
   "lint-staged": {
     "*.{js,ts}": [

package/rules/requests.n3

@@ -70,7 +70,7 @@ prefix earl: <http://www.w3.org/ns/earl#>
     } .
 
     (
-      "node " "lib/merge-curl-output.js"!file:libPath " "
+      "bin/merge-curl-output.sh"!file:libPath " "
       ?responseBodyFile
       " > " ?responseFile
     )!string:concatenation!e:exec .