open-index/open-npm huggingface dataset:
npm package: @pact-toolbox/pact-transformer-linux-x64-gnu
Description: High-performance Pact code transformer with Rust implementation
Author: Salama Ashoush
Latest version: 0.1.0

# `@pact-toolbox/pact-transformer-linux-x64-gnu`

This is the **x86_64-unknown-linux-gnu** binary for `@pact-toolbox/pact-transformer`
npm package: @pact-toolbox/pact-transformer-win32-x64-msvc
Description: High-performance Pact code transformer with Rust implementation
Author: Salama Ashoush
Latest version: 0.1.0

# `@pact-toolbox/pact-transformer-win32-x64-msvc`

This is the **x86_64-pc-windows-msvc** binary for `@pact-toolbox/pact-transformer`
npm package: @pact-toolbox/prelude
Description: Streamlines the downloading and deployment of standard Kadena contracts.
Author: Salama Ashoush
Latest version: 2.0.0

# @pact-toolbox/preludes

Streamlines the downloading and deployment of standard Kadena contracts.

## Table of Contents

- [@pact-toolbox/preludes](#pact-toolboxpreludes)
  - [Table of Contents](#table-of-contents)
  - [Introduction](#introduction)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Downloading Preludes](#downloading-preludes)
    - [Deploying Preludes](#deploying-preludes)

## Introduction

The `@pact-toolbox/preludes` module provides utilities for managing the downloading and deployment of standard Kadena contracts, known as preludes. This package aims to simplify the process of handling contract dependencies and ensuring they are properly deployed to a Kadena network.

## Installation

To install the package, run:

```bash
npm install @pact-toolbox/preludes
```

## Usage

### Downloading Preludes

You can download the necessary preludes by using the downloadPreludes function. This function resolves and downloads all specified preludes based on the provided configuration.

Example:

```typescript
import { downloadAllPreludes } from "@pact-toolbox/preludes";
import { PactToolboxClient } from "@pact-toolbox/runtime";

const myPactToolboxClient = new PactToolboxClient();
const config = {
  contractsDir: "./contracts",
  preludes: ["kadena/chainweb", "kadena/marmalade"],
  client: myPactToolboxClient,
};

await downloadAllPreludes(config);
```

### Deploying Preludes

After downloading the preludes, you can deploy them using the deployPreludes function. This function ensures that all resolved preludes are deployed to the Kadena network.

Example:

```typescript
import { deployPreludes } from "@pact-toolbox/preludes";
import { PactToolboxClient } from "@pact-toolbox/runtime";

const myPactToolboxClient = new PactToolboxClient();
const config = {
  contractsDir: "./contracts",
  preludes: ["kadena/chainweb", "kadena/marmalade"],
  client: myPactToolboxClient,
};

await deployPreludes(config);
```
npm package: @pacta-app/qrcode-react
Description: React component to generate QRCode with logo
Author: Pacta
Latest version: 1.0.1

# qrcode-react

This is a fork of [cssivision/qrcode-react](https://github.com/cssivision/qrcode-react) with the only intention to remove hard coded style and attributes. The stiling should be done with selectors in css files and must not be implemented hard coded.

A React component to generate [QRCode](http://en.wikipedia.org/wiki/QR_code) with logo.
Inspired by [zpao/qrcode.react](https://github.com/zpao/qrcode.react), also support chinese.

## Installation

```sh
npm install pacta-app/qrcode-react
```

## Usage

```js
var React = require("react");
var ReactDOM = require("react-dom");
var QRCode = require("pacta-app/qrcode-react");

ReactDOM.render(<QRCode value="http://facebook.github.io/react/" />, mountNode);
```

## Available Props

| prop         | type                  | default value                       |
| ------------ | --------------------- | ----------------------------------- |
| `value`      | `string`              | `http://facebook.github.io/react/`  |
| `size`       | `number`              | `128`                               |
| `bgColor`    | `string` (CSS color)  | `"#FFFFFF"`                         |
| `fgColor`    | `string` (CSS color)  | `"#000000"`                         |
| `logo`       | `string` (URL / PATH) |
| `logoWidth`  | `number`              | `size * 0.2`                        |
| `logoHeight` | `number`              | Proportional scaling to `logoWidth` |

<img src="qrcode.png" height="256" width="256">
npm package: @pacta-app/react-blockies
Description: Ethereum Style Identicons for React
Author: Pacta
Latest version: 1.0.0

# React Blockies

This is a fork of [cssivision/qrcode-react](https://github.com/cssivision/qrcode-react), which a simple port of [alexvandesande/blockies](https://github.com/alexvandesande/blockies) to a react component. The original has been forked with the only intention to remove hard coded style and attributes. The stiling should be done with selectors in css files and must not be implemented hard coded.

# Example:

```javascript
import Blockies from 'react-blockies';

export const myBlockies = () => (
  <Blockies
    seed="Jeremy" {/* the only required prop; determines how the image is generated */}
    size={10} {/* number of squares wide/tall the image will be; default = 15 */}
    scale={3} {/* width/height of each square in pixels; default = 4 */}
    color="#dfe" {/* normal color; random by default */}
    bgColor="#ffe" {/* background color; random by default */}
    spotColor="#abc" {/* color of the more notable features; random by default */}
    className="identicon" {/* optional class name for the canvas element; "identicon" by default */}
  />
)
```
npm package: @pactcore/sdk
Description: TypeScript SDK for integrating with PACT Core services
Latest version: 0.2.0

# PACT SDK

PACT SDK is the runtime toolkit for building on top of `pactcore/core`.

This package is designed for **human-agent protocol participation**, not only endpoint calls.

## Design Baseline

- protocol semantics come from the PACT whitepaper (`core`)
- SDK focuses on loop execution, recovery, policy enforcement, and economic composition
- transport helpers are supporting pieces, not the center

## Current Capabilities

- typed `PactSdk` transport client
- `WorkerRuntime` with:
  - `runOnce()`
  - `runLoop()`
  - event feed polling (cursor-based)
  - checkpoint persistence hooks
- event source adapters:
  - `HttpMissionEventFeed`
  - `InMemoryMissionEventFeed`
- in-memory checkpoint store:
  - `InMemoryWorkerRuntimeCheckpointStore`
- economics helpers:
  - `buildCompensationModel`
  - `summarizeCompensationByAsset`

## Economic Model Support

Compensation composition supports mixed reward legs such as:

- USDC / stablecoins
- LLM token allowances
- cloud credits
- API quota credits

## Install

```bash
bun add @pactcore/sdk
# or
npm i @pactcore/sdk
```

## Quick Example

```ts
import {
  createWorkerRuntime,
  allowAllWorkerRuntimePolicy,
  buildCompensationModel,
} from "@pactcore/sdk";

const compensation = buildCompensationModel({
  legs: [
    {
      payerId: "issuer-1",
      payeeId: "agent-1",
      assetId: "usdc-mainnet",
      amount: 15,
      unit: "USDC",
    },
  ],
});

const runtime = createWorkerRuntime({
  agentId: "agent-1",
  missionSource,
  policy: allowAllWorkerRuntimePolicy(),
  handlers,
});

await runtime.runLoop({ iterations: 10 });
```

## Local Development

```bash
bun install
bun test
bun run typecheck
```

## Documentation

- `docs/architecture.md`
- `docs/agent-sdk-direction.md`
- `docs/runtime-composition.md`
- `docs/compatibility.md`
- `docs/economics.md`
npm package: @pactflow/drift
Description: Wraps the drift CLI for your platform.
Latest version: 2603.0.8-beta.20

# Drift

https://pactflow.github.io/drift-docs/

This package wraps the drift CLI for your platform. After installing, the `drift` command will be available in your local node_modules/.bin directory.

The package also exposes these bundled executables:

- `drift-auth`
- `drift-check-version`
- `drift-dump`
- `drift-generate-results`
- `drift-init`
- `drift-plugins`
- `drift-repl`
- `drift-verify`
- `drift-versions`


## Usage

```
npm install @pactflow/drift
npx @pactflow/drift --help
```

## Supported platforms
- linux-aarch64
- linux-x86_64
- macos-aarch64
- macos-x86_64
- windows-x86_64
npm package: @pactflow/openapi-pact-comparator
Description: An OpenAPI Specification and Pact Comparison library
Author: Voon Siong Wong
Latest version: 1.14.0

# OpenAPI-Pact-Comparator

## What is this?

This compares OpenAPI schemas and Pact contracts to determine if they are
compatible. It is inspired by
[swagger-mock-validator](https://github.com/pactflow/swagger-mock-validator)
and aims to retain a mostly compatible interface.

## Why rewrite it?

[swagger-mock-validator](https://github.com/pactflow/swagger-mock-validator)
has aged, and is very difficult to extend and improve on.

It is also very slow primarily due to inefficient use of
[ajv](https://ajv.js.org/); schemas are unnecessarily recompiled everytime
instead of being cached.

## How is this better?

**Schemas are compiled once, and reused where possible**. In practical terms,
this gives us an improvement exceeding 20x in real-world comparisons. In some
cases, this was 50x faster!

**Referenced schemas are NOT inlined**. They are kept as references to keep the
size of complex schemas down. We need to do this anyway to support circular
references. Further, unused references are skipped to speed up schema
compilation in AJV.

**Multiple pacts can be compared in one invocation to maximise schema reuse**.
Instead of performing the comparison per pair of OAS + Pact, we can reuse the
compiled OAS schemas across multiple Pacts.

**A fast HTTP router is used to match provider routes**. Instead of iterating
through an array of routes, we use [Radix
Tree](https://en.wikipedia.org/wiki/Radix_tree) search using
[find-my-way](https://github.com/delvedor/find-my-way) This allows large
providers to be traversed quickly.

**Computation is broken up to small units using async generators**. This leads
to low event loop delays, suitable for high concurrency servers.

## Usage

With error handling omitted for brevity:

```
import { Comparator } from "openapi-pact-comparator";

// openapi is object from JSON.parse() or yaml.load()
const comparator = new Comparator(openapi);

// pacts is array of objects the same way
for (const pact of pacts) {
  for await (const result of comparator.compare(pact)) {
    console.log(result);
  }
}
```

## Quirks mode

To retain compatibility with
[swagger-mock-validator](https://github.com/pactflow/swagger-mock-validator),
an environment variable `QUIRKS` can be set [to any value]. When this is true,
all of SMV quirks are reproduced in case you are unable to migrate immediately.

The quirks can also be enabled/disabled by adding to the `info` section of the
OAS some extensions in the form of `x-opc-config-${quirk-name}`, where quirks
are listed [here](./src/utils/config.ts).

This mode may be removed eventually, so you should always endeavour to try to
update your comparisons to use the latest functionality.
npm package: @pactilis/dbcopy
Description: A node library and command line program to copy data from one sql server database to another
Latest version: 0.5.1

# dbcopy

A node library and command line program to copy data from one sql server database to another

## Install

```sh
npm install -g @pactilis/dbcopy
```

Or

```sh
yarn global add @pactilis/dbcopy
```

## Usage in command line:

```sh
dbcopy --from <fromDb> --database <destDb> --server <dbServer> --user <dbUser> --password <dbPassword>
```

The tow databases must be of the same structure.
The program connect to the destination server only. If the source database is on another server,
you need to create a linked server and specify `--from [<linked server>].[<source db name>]` parameter.

### Options

```sh
  --help      Show help                                                                [boolean]
  --version   Show version number                                                      [boolean]
  --from      Origin database reference ex. [<linked-server>].[<dbname>] or <dbname>   [string] [required]
  --database  Destination database name                                                [string] [required]
  --server    Server host or ip address                                                [string] [required]
  --user      db server login                                                          [string] [required]
  --password  db server password                                                       [string] [required]
```

## Usage as library

```js
const { dbCopy } = require("@pactilis/dbcopy");

dbcopy({
  config: {
    server: "<server>",
    user: "<user>",
    password: "<password>",
    database: "<destination database name>"
  },
  from: "<source database name>"
}).then(() => console.log("done"))
.catch(err => console.err(err))

```
npm package: @pactima/node
Description: Pactima API wrapper for Node.js
Author: Pactima
Latest version: 1.0.0-beta.4

# Pactima Node.js Library

The Pactima Node library provides convenient access to the Pactima API from
applications written in server-side JavaScript / TypeScript.


## Documentation

See the [Pactima's Developer docs](https://developers.pactima.com/) for the API reference, guides and examples.


## Requirements

Node 12 or higher.

## Installation

Install the package with:

```sh
npm install @pactima/node
```

## Usage

The package needs to be configured with your authentication token which can be an oAuth access token or your team's API key.
Require it with the key's value:

<!-- prettier-ignore -->
```js
const { PactimaApi } = require('@pactima/node');

const pactimaApi = new PactimaApi('pctm_sk_live_...');

pactimaApi.eSignaturePackages.list({ limit: 10 })
    .then((res: any) => console.log(res.data))
    .catch((err: any) => console.error(err));
```

Or using ES modules and `async`/`await`:

```js
import { PactimaApi } from '@pactima/node';

const pactimaApi = new PactimaApi('pctm_sk_live_...');

const res = await pactimaApi.eSignaturePackages.list({ limit: 10 });

console.log(res.data);
```

## Support

New features and bug fixes are released on the latest major version of the `@pactima/node` package. If you are on an older major version, we recommend that you upgrade to the latest in order to use the new features and bug fixes including those for security vulnerabilities. Older major versions of the package will continue to be available for use, but will not be receiving any updates.