open-index/open-npm huggingface dataset:
npm package: @maximdevoir/ati
Description: Awesome Test Insights is a lightweight TCP event router for ATC coordinator telemetry.
Latest version: 1.1.2

# ATI

Awesome Test Insights is a lightweight TCP event router for ATC coordinator telemetry.

## What it does

- listens for newline-delimited UTF-8 JSON events over TCP
- validates the incoming event envelope
- fans events out to one or more in-process consumers
- keeps consumer delivery isolated with per-consumer queues

ATI is intentionally **not** a database. Persistence is delegated to consumers such as `NDJSONConsumer`.

## Event transport

Each payload is one JSON object followed by a newline:

```json
{"version":1,"sessionId":"...","sequence":0,"timestamp":1.23,"type":"TestStarted","testPath":"ATC.Sample"}
```

## Quick example

```ts
import { ATIService, NDJSONConsumer, TerminalConsumer } from '@maximdevoir/ati';

const ati = new ATIService({
  host: '127.0.0.1',
  port: 8888,
  validateSchema: true,
});

ati
  .addConsumer(new NDJSONConsumer({ directory: './Saved/Logs/ATI' }))
  .addConsumer(new TerminalConsumer());

await ati.start();

console.log('ATI listening on', ati.getEndpoint());

// ...run ATC/ATO here...

await ati.stop();
```

## Built-in consumers

- `NDJSONConsumer` – appends events to an `.ndjson` file
- `TerminalConsumer` – prints a small human-readable summary
- `InMemoryConsumer` – useful in tests
npm package: @maximdevoir/ato
Description: `@maximdevoir/ato` provides TypeScript helpers for orchestrating ATC processes.
Latest version: 1.1.2

# ATO

`@maximdevoir/ato` provides TypeScript helpers for orchestrating ATC processes.

## Highlights

- coordinator-first native ATC runs
- on-demand external client spin-up driven by server log metadata
- optional `UnrealLag` proxy integration

## Install

```bash
pnpm add @maximdevoir/ato
```

## Usage

```ts
import {ATO, Orchestrator, OrchestratorMode} from '@maximdevoir/ato';

const e2e = ATO.fromCommandLine();

const dedicated = new Orchestrator(OrchestratorMode.DedicatedServer)
  .addTests('MyAwesomeProject.Category.Name')
  .configureUnrealLag({
    bindAddress: '127.0.0.1',
    bindPort: 0,
    serverProfile: 'Bad',
    clientProfile: 'Bad',
  });

e2e.addOrchestrator(dedicated);

const code = await e2e.start();

process.exit(code);
```

`ATO.fromCommandLine()` still accepts runtime overrides such as `--clients`, `--port`, `--timeout`, `--serverExe`,
`--clientExe`, `--dryRun`, and `--codecov`.
For native dedicated/listen coordinators, omitting `--clients` allows ATO to spawn external clients on demand as the
server requests them.
When `--codecov` is enabled, ATO wraps each spawned Unreal process with OpenCppCoverage, writes LCOV output to
`coverage/atc/<coordinator-or-client>-<randomDigits>.lcov.info`, and defaults coverage collection to project-owned
modules/sources
instead of Unreal Engine modules.
At the end of the session, ATO folds every `coverage/atc/**/*.info` file except `coverage/atc/merged.info` into a fresh
combined report, writing the result back to `coverage/atc/merged.info` while leaving the
individual reports in place.
For coordinator-driven external client spin-up, ATO now listens for direct ATI `TestStarted.requiredClients` events and
keeps the legacy stdout metadata parsing as a compatibility fallback, so client orchestration still works when stdout is
wrapped by tools such as OpenCppCoverage.
You can call `addOrchestrator(...)` multiple times to run several native coordinators sequentially from one top-level
ATO session.

## Code Coverage

Code coverage is available only on Windows. It requires OpenCppCoverage and the `lcov` exporter
from [covlcov](https://github.com/MaximDevoir/covlcov).