open-index/open-npm huggingface dataset:
npm package: @spokedev/healthchicken
Description: [![pipeline status](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/badges/master/pipeline.svg)](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/commits/master) [![coverage report](https://gitlab.spokedev.xyz/products/marketp
Latest version: 0.0.9

# healthchicken

[![pipeline status](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/badges/master/pipeline.svg)](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/commits/master)
[![coverage report](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/badges/master/coverage.svg)](https://gitlab.spokedev.xyz/products/marketplace/healthchicken/commits/master)

<img src="https://media.giphy.com/media/1gUn2j2RKcK0yaLKaO/giphy.gif"/>

Healthchicken is express middleware that binds routes to `${serviceName}/healthcheck/ping` and `${serviceName}/healthcheck/ready`. By default, if the app is healthy, these will always return `200` statuscodes and a `{message: 'OK'}` json body. You can also specify _dependent services_. These will be pinged by the `ready` route. If they are all good, the ready route will return a `200` else you are getting a `500`.

## Install

```
$ npm i @spokedev/healthchicken
```

## Usage

### Basic usage

```
const healthchicken = require("healthchicken");
const express = require("express");

const app = express();

app.use(healthchicken({
  serviceName: "cats_n_chickens"
}))

// we now have routes at `cats_n_chickens/healthcheck/ready` and `cats_n_chickens/healthcheck/ping`
```

### Specifying dependent services

```
const healthchicken = require("healthchicken");
const express = require("express");

const app = express();

app.use(healthchicken({
  serviceName: "cats_n_chickens",
  dependentUrls: ["http://some-other.service"]
}))

// `cats_n_chickens/healthcheck/ready` will now ping `http://some-other.service/healthcheck/ping`
// and fail if it doesn't get a 2xx back.
```

### Using a different prefix

```
const healthchicken = require("healthchicken");
const express = require("express");

const app = express();

app.use(healthchicken({
  serviceName: "cats_n_chickens",
  prefix: "deathwatch"
}))

// we now have routes at `cats_n_chickens/deathwatch/ready` and `cats_n_chickens/deathwatch/ping`
```

### Adding in version

If the version is found as an environment variable as `SERVICE_VERSION` then it will be output as part of the `ready` healthcheck.
npm package: @spokedev/node-unhandled
Description: A handler for unhandled errors/exceptions/rejections in node.
Author: Hugh Montgomery-Pott
Latest version: 0.0.5

# node-unhandled

## About
A library for gracefully handling uncaught promise rejections and unhandled exceptions that bubble up to the event loop.

## Why
Unhandled errors can cause your application to enter an unpredictable state. This lib helps you out by logging a trace and terminating the process.

Assuming you've got something to restart the process (e.g. a K8s service) your application will then restart in a predictable manner. This just leaves your monitoring to alert the issue, and your team to fix it :)

## What does it do?
The default behaviour will log a trace to `console.error` and terminate the process with exit code `1` via `process.exit(1)`.  
If you provide a custom logger, it will log to `logger.fatal`.  
You can provide custom handler functions as seen below.  

## How to use
Add it to your dependencies:
```sh
npm i @spokedev/node-unhandled
```

Then just one line for the default configuration:
```js
const Unhandled = require('@spokedev/node-unhandled');
const unhandled = Unhandled();
```

You can optionally provide a custom logger:
```js
const unhandled = Unhandled({
  logger: yourCustomLogger
})
```

Or custom handler functions:
```js
const exceptionHandler = (err, origin) => console.log(err, origin);
const rejectionHandler = (reason, promise) => console.log(reason);

const unhandled = Unhandled({
  exceptionHandler,
  rejectionHandler
});
```
npm package: @spokedev/puzzler
Description: A simple db migration manager
Author: jigsaw.xyz
Latest version: 1.3.11

# Puzzler By Jigsaw

Puzzler is a low configuration, stateful migration manager for Node.js.

## Installation

`npm install @spokedev/puzzler --save-dev`;

## Core Terminology

Transaction => A single up/down pair of actions to take.   
Migrate => Run a set of up transactions.   
Rollback => Run a set of down transactions.   

## Configuration

Puzzler expects database credentials to be provided via config file:

config.js:
```js
module.exports = {
  database: {
    name: 'database name',
    host: 'localhost',
    port: 26257,
    user: 'root',
    password: 'unsecurepassword',
    pool_size: { min: 0, max: 1 }
  }
};
```

## State Management

Puzzler will create a migrations history table in your db which contains the history of every migration carried out. This is used to track the current state of the db, and ensure the correct migrations are carried out. 

## CLI
Puzzler supports three actions. 

### Make

Creates a new template migration file in target directory, with given name.   

`./node_modules/bin/puzzler make --transactionDir=<transactionDir> --migrationName=addClientTable`

[REQUIRED] transactionDir => The location to put the new transaction template.    
[OPTIONAL] migrationName => The name to give to the new transaction. Defaults to migration.    

### Migrate

Carries out up migrations in timestamp order.    

`./node_modules/bin/puzzler migrate --transactionDir=<transactionDir> --config=config.js --partial=1`

[REQUIRED] transactionDir => The location to source transactions from.     
[REQUIRED] config => The location of config file (see Configuration).   
[OPTIONAL] partial => Option to carry out a specified number of up transactions. Defaults to 0 (i.e. run all migrations).

### Rollback

Carries out down rollbacks in timestamp order.    

`./node_modules/bin/puzzler rollback --transactionDir=<transactionDir> --config=config.js --partial=1`

[REQUIRED] transactionDir => The location to source transactions from.     
[REQUIRED] config => The location of config file (see Configuration).   
[OPTIONAL] partial => Option to carry out a specified number of up transactions. Defaults to 0 (i.e. run all migrations). 

## Module

Puzzler can be used as part of a wider codebase by requiring the module. When used this way it expects to be provided a knex.js connection pool:

```js
const puzzler = require('@spokedev/puzzler');
const knex = require('knex');

const pool = knex({
  client: 'pg',
  version: '0.0',
  connection: {
    user: 'user',
    password: 'password',
    host: 'localhost',
    database: 'databaseName',
    port: 2567
  },
  pool: { min: 0, max: 1 }
});

// make a new transaction
puzzler.make({
  transactionDir: `${__dirname}/transactions`,
  migrationName: 'addClientsTable'
});

// run all migrations
puzzler.migrate({         
  transactionDir: `${__dirname}/transactions`,
  pool: pool,
  partial: 0 
});

// rollback all migrations
puzzler.rollback({         
  transactionDir: `${__dirname}/transactions`,
  pool: pool,
  partial: 0 
});
```
npm package: @spokest/langchain
Description: LangChain memory integration for Spokest Brain
Latest version: 1.0.0

# @spokest/langchain

LangChain memory integration for [Spokest Brain](https://spokest.com). Give your LangChain chains persistent, associative memory powered by the Spokest Brain API.

## Install

```bash
npm install @spokest/langchain @langchain/core
```

## Usage

```ts
import { ChatOpenAI } from '@langchain/openai';
import { ConversationChain } from 'langchain/chains';
import { SpokestMemory } from '@spokest/langchain';

const memory = new SpokestMemory({
  apiKey: 'sk-your-spokest-api-key',
  baseUrl: 'https://brain-api.spokest.com', // optional, this is the default
});

const llm = new ChatOpenAI({ model: 'gpt-4o' });
const chain = new ConversationChain({ llm, memory });

const response = await chain.invoke({ input: 'What did we discuss about the product launch?' });
console.log(response.response);
```

## Configuration

| Parameter | Default | Description |
|-----------|---------|-------------|
| `apiKey` | (required) | Your Spokest Brain API key |
| `baseUrl` | `https://brain-api.spokest.com` | Brain API base URL |
| `memoryKey` | `memories` | Key used in the chain's memory variables |

## How it works

- **`loadMemoryVariables`** -- Calls `/v1/memory/recall` with the current user input to retrieve relevant memories. Returns them formatted as a bulleted list under the configured `memoryKey`.
- **`saveContext`** -- Calls `/v1/memory/store` with the full conversation turn (user input + assistant output) after each chain invocation.

## License

MIT
npm package: @spokest/vercel-ai
Description: Vercel AI SDK tools for Spokest Brain memory
Latest version: 1.0.0

# @spokest/vercel-ai

Vercel AI SDK tools for [Spokest Brain](https://spokest.com) memory. Give your AI applications persistent, associative memory with two simple tools.

## Install

```bash
npm install @spokest/vercel-ai ai zod
```

## Usage

```ts
import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';
import { createMemoryTools } from '@spokest/vercel-ai';

const [recallMemory, storeMemory] = createMemoryTools({
  apiKey: 'sk-your-spokest-api-key',
  baseUrl: 'https://brain-api.spokest.com', // optional, this is the default
});

const result = await generateText({
  model: openai('gpt-4o'),
  tools: { recallMemory, storeMemory },
  prompt: 'What do you remember about our product roadmap?',
});

console.log(result.text);
```

## Tools

### `recall_memory`

Retrieves relevant memories from Spokest Brain based on a semantic query.

**Input:**
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `query` | `string` | yes | The search query |
| `maxResults` | `number` | no | Max memories to return |

### `store_memory`

Stores a new memory in Spokest Brain.

**Input:**
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `text` | `string` | yes | The text to store |
| `importance` | `number` | no | Importance score (0-1) |
| `topics` | `string[]` | no | Topic tags |

## Configuration

| Parameter | Default | Description |
|-----------|---------|-------------|
| `apiKey` | (required) | Your Spokest Brain API key |
| `baseUrl` | `https://brain-api.spokest.com` | Brain API base URL |

## License

MIT
npm package: @spolm/tracer
Description: Official Spolm SDK for tracing and logging agent runs
Author: Spolm
Latest version: 1.0.0

# @spolm/tracer

Official Spolm SDK for tracing and logging agent runs in Node.js applications.

## Installation

```bash
npm install @spolm/tracer
```

## Quick Start

```javascript
const Tracer = require('@spolm/tracer');

// Initialize the tracer
const tracer = new Tracer('YOUR_API_KEY', 'YOUR_AGENT_ID');

// Start a run
const runId = tracer.startRun('Build a machine learning pipeline', {
  framework: 'TensorFlow',
  cloud_provider: 'AWS'
});

// Log steps using the decorator pattern
const myFunction = tracer.logStep({
  stepName: 'data_preprocessing',
  stepType: 'tool_call',
  provider: 'pandas'
})(async (data) => {
  // Your function logic here
  const processed = await processData(data);
  
  // Record token usage if applicable
  if (tracer.recordTokens) {
    tracer.recordTokens({ input: 100, output: 200, total: 300 });
  }
  
  return processed;
});

// Use your function
await myFunction(someData);

// End the run
tracer.endRun('Pipeline successfully deployed', 'complete');
```

## API Reference

### `new Tracer(API_KEY, AGENT_ID, options)`

Creates a new Tracer instance.

**Parameters:**
- `API_KEY` (string, required): Your Spolm API key
- `AGENT_ID` (string, required): Your agent ID
- `options` (object, optional): Configuration options

### `tracer.startRun(userTask, metadata)`

Starts a new tracing run.

**Parameters:**
- `userTask` (string, required): Description of the task
- `metadata` (object, optional): Additional metadata

**Returns:** `run_id` (string)

### `tracer.logStep({ stepName, stepType, provider, options })`

Returns a decorator function to wrap your functions for automatic step logging.

**Parameters:**
- `stepName` (string, required): Name of the step
- `stepType` (string, required): Type of step (e.g., 'tool_call', 'llm_call')
- `provider` (string, optional): Tool/provider name
- `options` (object, optional): Additional step options

**Returns:** Decorator function

### `tracer.endRun(finalResult, status)`

Ends the current run and sends logs to Spolm.

**Parameters:**
- `finalResult` (string, required): Final output/result
- `status` (string, optional): Status ('complete', 'failed', etc.)

## License

MIT
npm package: @spon/connect
Description: spon
Author: magicspon@gmail.com
Latest version: 1.0.1

## Rematch/@spon/core integration

## Installation

`npm install @spon/core @spon/connect --save` or `yarn add @spon/core @spon/connect --save`

Peer Dependency

- @spon/core ^2.0.2

See [@spon/core](https://github.com/magicspon/spon-core/blob/master/README.md) for documentation

You’ll need to know how to use rematch to use this feature. Spon.js exposes a hook for subscribing to store updates. It uses the connect function to bind the store state and reducers to the module

/store/index.js

```javascript
import { init } from '@rematch/core'
import connectStore from '@spon/connect'

const store = init({
	models: {
		count: {
			state: 0, // initial state
			reducers: {
				increment(state, payload) {
					return state + payload
				}
			}
		}
	}
})

// this creates a function that is used to bind modules to the store
export const connect = connectStore(store)

export default store
```

/behaviours/example

```javascript
import { connect } from '@/store'
import { domEvents, withPlugins } from '@spon/plugins'

function counter({ plugins: { addEvents }, store, subscribe }) {
	const node = document.getElementById('value')

	addEvents({
		'click button': () => {
			store.dispatch.increment(1)
		}
	})

	subscribe(
		({ current }) => {
			node.textContent = current.count
		},
		['count'] // dependencies
	)
}

const mapState = store => {
	return {
		count: store.count
	}
}
const mapDispatch = ({ count }) => ({ ...count })

export default withPlugins(domEvents)(
	connect({ mapState, mapDispatch })(counter)
)
```
npm package: @spon/domevents
Description: a small wrapper around dom-delegate for backbone object styled events
Author: magicspon@gmail.com
Latest version: 2.0.0

## Install

`yarn add @spon/domevents`

or

`npm install @spon/domevents --save`

```javascript
import domEvents from '@spon/domevents'

const { addEvents, removeEvents } = domEvents(document.body)

addEvents({
	'click [data-toggle-button]': (e, elm) => {
		e.preventDefault()
		elm.classList.toggle('is-active')
	}
})
```

All events, by default are delegated to the node given to the initial setup. If you want to delegate to a different element, you can pass in a Dom node as the first argument , eg

```javascript
addEvents(document.querySelector('.my-node'), {
	'click [data-toggle-button]': (e, elm) => {
		e.preventDefault()
		elm.classList.toggle('is-active')
	}
})
```
npm package: @spondylatlas/agent-sdk
Description: TypeScript SDK for the SpondylAtlas research platform API
Latest version: 1.0.1

# @spondylatlas/agent-sdk

TypeScript SDK for the [SpondylAtlas](https://spondylatlas.web.app) research platform API.

SpondylAtlas is an open-source research and community platform for axial spondyloarthritis (axSpA / Morbus Bechterew).

## Installation

```bash
npm install @spondylatlas/agent-sdk
```

## Usage

```typescript
import { SpondylAtlasClient } from '@spondylatlas/agent-sdk';

const client = new SpondylAtlasClient({
  clientId: process.env.SPONDYLATLAS_CLIENT_ID!,
  clientSecret: process.env.SPONDYLATLAS_CLIENT_SECRET!,
  // baseUrl defaults to the production API
});

// Search papers
const papers = await client.papers.search({ q: 'TNF inhibitors' });
console.log(`Found ${papers.total} papers`);

// Get a single paper
const paper = await client.papers.get('paper-id');

// Submit a new paper
await client.papers.submit({
  title: 'TNF inhibitors in axSpA: a meta-analysis',
  abstract: 'Background: ...',
  authors: ['Smith J', 'Doe A'],
  url: 'https://pubmed.ncbi.nlm.nih.gov/12345678/',
  source: 'pubmed',
  doi: '10.1234/example',
  pubmedId: 'PMID12345678',
});

// List hypotheses
const hypotheses = await client.hypotheses.list({ status: 'open' });

// Review a hypothesis
await client.hypotheses.review('hypothesis-id', {
  verdict: 'challenged',
  argument: 'The cited studies have methodological limitations...',
  confidence: 'medium',
});
```

## Authentication

Agents authenticate via `clientId` / `clientSecret` (OAuth2 client credentials flow). Credentials are issued per agent — contact the SpondylAtlas team or register via the Admin API.

Tokens are automatically fetched, cached (with 5-minute buffer), and refreshed by the client.

## Configuration

```typescript
const client = new SpondylAtlasClient({
  clientId: '...',       // required
  clientSecret: '...',   // required
  baseUrl: '...',        // optional, defaults to production API
  timeout: 30000,        // optional, request timeout in ms (default: 30s)
  retries: 2,            // optional, retry count on failure (default: 2)
});
```

## Roles & Scopes

| Role | Scopes |
|------|--------|
| `reviewer` | `papers:read`, `hypotheses:read`, `papers:review`, `hypotheses:review` |
| `researcher` | `papers:read`, `papers:write`, `hypotheses:read` |
| `admin` | All scopes |

## Error Handling

```typescript
import {
  SpondylAtlasError,
  AuthenticationError,
  ForbiddenError,
  NotFoundError,
  ValidationError,
  RateLimitError,
} from '@spondylatlas/agent-sdk';

try {
  await client.papers.search();
} catch (err) {
  if (err instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${err.retryAfter}s`);
  } else if (err instanceof AuthenticationError) {
    console.log('Check your clientId/clientSecret');
  } else if (err instanceof SpondylAtlasError) {
    console.log(`API error: ${err.message} (${err.code}, HTTP ${err.status})`);
  }
}
```

## License

MIT
npm package: @sponge-libs/uikit
Description: Set of UI components for sponge projects
Latest version: 0.1.25

# Sponge UIkit (fork Pancake)

[![Version](https://img.shields.io/npm/v/@sponge-libs/uikit)](https://www.npmjs.com/package/@sponge-libs/uikit)

Sponge UIkit is a set of React components and hooks used to build pages on Sponge's apps. It also contains a theme file for dark and light mode.

## Install

`yarn add @sponge-libs/uikit`

## Setup

### Theme

Before using Sponge UIkit, you need to provide the theme file to styled-component.

```
import { ThemeProvider } from 'styled-components'
import { light, dark } from '@sponge-libs/uikit'
...
<ThemeProvider theme={isDark}>...</ThemeProvider>
```

### Reset

A reset CSS is available as a global styled component.

```
import { ResetCSS } from '@sponge-libs/uikit'
...
<ResetCSS />
```

### Types

This project is built with Typescript and export all the relevant types.
npm package: @sponge-libs/uikit-love
Description: Set of Love UI components for sponge projects
Latest version: 0.1.15

# Sponge UIkit (fork Pancake)

[![Version](https://img.shields.io/npm/v/@sponge-libs/uikit)](https://www.npmjs.com/package/@sponge-libs/uikit)

Sponge UIkit is a set of React components and hooks used to build pages on Sponge's apps. It also contains a theme file for dark and light mode.

## Install

`yarn add @sponge-libs/uikit`

## Setup

### Theme

Before using Sponge UIkit, you need to provide the theme file to styled-component.

```
import { ThemeProvider } from 'styled-components'
import { light, dark } from '@sponge-libs/uikit'
...
<ThemeProvider theme={isDark}>...</ThemeProvider>
```

### Reset

A reset CSS is available as a global styled component.

```
import { ResetCSS } from '@sponge-libs/uikit'
...
<ResetCSS />
```

### Types

This project is built with Typescript and export all the relevant types.
npm package: @spongebug/dep-doctor
Description: Scan repos for known dependency problems and find affected source files
Latest version: 1.0.2

# dep-doctor 🩺

> Scan a folder of repos for known dependency vulnerabilities — with a **nightly-updated CVE feed**, **real-time OSV.dev lookup**, and optional **deep source-code analysis**.

```
$ dep-doctor scan ./my-projects --deep

◆ repo: my-api
  [HIGH    ] npm-axios-csrf-ssrf-CVE-2023-45857  axios @ 0.27.2 → 1.6.0
             Axios CSRF token leak via cross-origin redirect
             ⚑ 2 affected location(s):
               src/server.js line 8 [likely]
                 const result = await axios.get(req.query.url);
                 → Upgrade axios to >=1.6.0 and validate URLs before passing to axios.

◆ repo: legacy-app
  [CRITICAL] npm-lodash-prototype-pollution-CVE-2019-10744  lodash @ 4.17.15 → 4.17.21
             Lodash prototype pollution via defaultsDeep / merge / set
```

## Install

```bash
npm install -g @spongebug/dep-doctor
```

Or download binaries from [GitHub Releases](https://github.com/SpongeBUG/dep-doctor/releases).

## Usage

```bash
dep-doctor scan ./my-projects              # Scan with nightly feed
dep-doctor scan . --online --deep          # Live OSV + source analysis
dep-doctor scan . --fix                    # Auto-fix manifests
dep-doctor scan . --watch                  # Re-scan on file changes
dep-doctor scan . -r json -o report.json   # JSON output
dep-doctor scan . --severity high          # Filter by severity
dep-doctor problems list                   # List known problems
```

## Features

- **3-layer vulnerability data**: built-in → nightly OSV feed → live OSV.dev lookup
- **4 ecosystems**: npm, pip, Go, Rust
- **Deep scan**: regex source patterns find vulnerable API usage in code
- **Auto-fix**: `--fix` updates manifests to safe versions
- **Watch mode**: `--watch` re-scans on manifest changes
- **LLM patterns**: `--generate-patterns` uses AI to create source detection rules
- **GitHub Action**: use `SpongeBUG/dep-doctor@v1.0.0` in CI

Full documentation: https://github.com/SpongeBUG/dep-doctor
npm package: @spongex/async-for-each
Description: Async version of forEach
Author: Matthew Evans
Latest version: 1.0.2

# async-for-each

### Async For Each
Async version of the forEach function.

Install to your existing project using:
```
npm i @spongex/async-for-each
```

Include ECMAScript:
```
import { asyncForEach } from '@spongex/async-for-each'
```

Include CommonJS:
```
const { asyncForEach } = require('@spongex/async-for-each')
```

# Usage

### asyncForEach: async (array: Array<any>, callback: Function) => Promise<void>

## Example:

```
const collection:Array<number> = [ 1, 2, 3, 4, 5 ]

asyncForEach(collection, async (item) => {
  // do something asynchronous with item
})
```

# Changelog

## 1.0.2
- Dependencies bump

## 1.0.1
- Comment error, quick fix

## 1.0.0
- Initial release
npm package: @spongex/async-resolver
Description: Await for asynchronous data
Author: Matthew Evans
Latest version: 1.0.2

#  Async Resolver Class

### Await for asynchronous data

Install to your existing project using:
```
npm i @spongex/async-resolver
```

Include ECMAScript:
```
import { AsyncResolver } from '@spongex/async-resolver'
```

Include CommonJS:
```
const { AsyncResolver } = require('@spongex/async-resolver')
```

# Usage

First create a new resolver object:
```
let myResolver = new AsyncResolver()
```

Start an asynchronous process, then await the promise to be resolved or rejected.
```
await myResolver.promise.then(data => {
  console.log(`Received: ${data}`)
}).catch(msg => {
  console.log(`Canceled: ${msg}`)
})
```

Resolve the promise:
```
myResolver.resolve(data)
```

Reject the promise:
```
myResolver.reject('This was rejected')
```

# Changelog

## 1.0.2
- Dependencies bump

## 1.0.1
- README fix

## 1.0.0
- Initial release
npm package: @spongex/check-github-releases
Description: Check a GitHub Releases via the API and parse download links
Author: Matthew Evans
Latest version: 1.1.0

#  check-github-releases

Check a GitHub Releases via the API and parse download links

Install to your existing project using:
```
npm i @spongex/check-github-releases
```

Include ECMAScript:
```
import { checkGitHubReleases } from '@spongex/check-github-releases'
```

Include CommonJS:
```
const { checkGitHubReleases } = require('@spongex/check-github-releases')
```

# Usage

### checkGitHubReleases: async (
### __GitHubURL__: string,
### opts?:[ { group:Extensions, extensions:Array<string> } ]
### ) => Promise<Releases>

#### Takes the following parameters:
- `__GitHubURL__` A string of the GitHub Releases API URL
- `opts` Optional parameter to add additional extension groups to check.
This is an array that takes an object in the following format:
  - `group` The asset group to add to.  Valid options are:  Extensions.winExt, Extensions.macExt, Extensions.linExt
  - `extensions` An array of strings containing the extensions to add to the parser

#### Returns an object in the following format:
- `winURLs` An array of `URLAsset` of parsed Windows assets
- `macURLs` An array of `URLAsset` of parsed Mac assets
- `linURLs` An array of `URLAsset` of parsed Linux assets
- `sourceURLs` An array of `URLAsset` of parsed source code assets
- `message` Error code message if any
- `error` Error flag, true if error else false

The `URLAsset` is an object with the following format:
- `name` A string with the filename
- `url` A string with the URL to download the asset

# Changelog

## 1.1.0
- Added the following extentions to Mac:
  - `pkg`, `mas`, `mas-dev`
- Added the following extentions to Linux:
  - `freebsd`, `p5p`, `apk`

## 1.0.0
- Initial release
npm package: @spongex/comment-updater
Description: Batch updates code comments at the top of source files
Author: Matthew Evans
Latest version: 2.0.1

# Comment Updater NodeJS Script

__WARNING!__  This script mass-modifies source code files.  Use at your own risk!

Install globally:
```
npm i -g @spongex/comment-updater
```

Or per-project as a dev-dependency:
```
npm i @spongex/comment-updater --save-dev
```

Batch updates code comments at the top of source files.

Create a __.comment_updater_config.json__ file in the project folder where the command will be ran.
See the following example:
```
{
  "author": "Time Lincoln",
  "comment_blocks": [
    {
      "name": "block1",
      "block": "\\author: $AUTHOR\n\\version:  $VERSION\n\\date:  2019-$YYYY",
      "comment_start": "/*!",
      "comment_end": " */",
      "line_delimiter": " * "
    },
    {
      "name": "block2",
      "block": "second block\nlazy example",
      "comment_start": "/*!",
      "comment_end": " */",
      "line_delimiter": " * "
    }
  ],
  "jobs": [
    {
      "job": "Source files",
      "block": "block2",
      "location": "/home/matthew/Projects/wtengine/src",
      "extension": ".cpp",
      "recursive": "true"
    },
    {
      "job": "Header files",
      "block": "block1",
      "location": "/home/matthew/Projects/wtengine/include/wtengine",
      "extension": ".hpp"
    }
  ]
}
```

A file __.comment_updater.log__ will be created with the results of the run.

## Variables

The following variables can be used in comment blocks:
- __$MM__ - Current month in MM format.
- __$DD__ - Current day in DD format.
- __$YYYY__ - Current year in YYYY format.
- __$PROJECT__ - Set with __settings['project']__
- __$AUTHOR__ - Set with __settings['author']__
- __$VERSION__ - Set with __settings['version']__
- __$COPYRIGHT__ - Set with __settings['copyright']__
- __$EMAIL__ - Set with __settings['email']__
- __$WEBSITE__ - Set with __settings['website']__
- __$CURRENT_FILENAME__ - The name of the file being edited.

## Optional Settings

The following additional options can also be set:
- __settings['verbose']__ - Show additional output.
- __settings['nologging']__ - Disable logging.

These can also be set on the command line using *-v* or *--verbose* and *--nologging*.

Passing the *-t* or *--test* option will not modify files but instead show the output to console.

# Changelog

## 2.0.1
- Bump packages and relocated project on GitHub
- Updated project name to proper NPM formatting
npm package: @spongex/create-random
Description: Create random data
Author: Matthew Evans
Latest version: 1.0.0

#  create-random

Simple script to generate random data

Install globally to run anywhere:
```
npm i -g @spongex/create-random
```

Uses the [NodeJS crypto](https://nodejs.org/api/crypto.html) library to generate random data

## Usage

Generate random numbers:
```
npx create-random numbers 12
```

Generate random letters:
```
npx create-random letters 10
```

Generate random numbers and letters:
```
npx create-random alphanum 42
```

Generate random hex values:
```
npx create-random hex 16
```

# Changelog

## 1.0.0
- Initial release
npm package: @spongex/docbuilder
Description: Run document generators for multiple projects
Author: Matthew Evans
Latest version: 2.1.1

# Docbuilder NodeJS Script

Run multiple document generators for multiple projects with one command simultaneously.  Then merge them all into a single directory!

__Performs command injection, use at your own risk!  Please read documentation before use!__

Requires the use of third party documentation generators such as [Doxygen](https://www.doxygen.nl/index.html), [JSDoc](https://jsdoc.app/) or [Typedoc](https://typedoc.org/).

Install globally:
```
npm i -g @spongex/docbuilder
```

Or per-project as a dev-dependency:
```
npm i -D @spongex/docbuilder
```

## Usage

Inside the directory you wish to generate the documentation in, create a `.docbuilder.config.json` file with the following format:
```
{
  "generators": {
      "doxygen": "doxygen .doxyfile",
      "jsdoc": "npx jdsoc index.js",
      "typedoc": "npx typedoc"
  },
  "jobs": [
    {
      "name": "wtengine",
      "generator": "doxygen",
      "path": "/home/matthew/Projects/wtengine",
      "checkfolder": "true"
    },
    {
      "name": "ppms",
      "generator": "doxygen",
      "path": "/home/matthew/Projects/ppms",
      "out": "ppms-docs",
      "checkfolder": "true"
    },
    {
      "name": "wtgui",
      "generator": "typedoc",
      "path": "/home/matthew/Projects/wtgui",
    }
  ],
  "output_folder": "public/docs"
}
```

It is recommended to set the document generators to output to a directory named `docs/projectname` for proper merger.

Then just run the script in the output directory:
```
npx docbuilder
```

A `.docbuilder.log` file will be created with the results of each job.

The script works by running each generator locally in the project's directory, then combining the results into the current working directory.

## Generators
These are system commands used to launch each different document generator.

The following variables can be used:
- `$PROJECT` - The name of the project
- `$PROJECT_LOCATION` - The full path to the project
- `$OUTPUT_FOLDER` - The name of the output directory from settings

## Job Settings:
- `"name": "project-name"` - Name of the project
- `"generator": "gen"` - Which generator to use
- `"path": "project/path"` - Full path to the project

## Optional Global Settings:
- `"log_file": "filename"` - Change the filename of the log file
- `"output_folder": "foldername"` - Change the output directory name (default docs)
- `"nologging": "nologging"` - Disable logging

## Optional Job Settings:
- `"out": "out/folder"` - Output folder created by generator
- `"checkfolder": "true"` - Verify directory exists before generating docs
- `"removeold": "true"` - Delete the old documentation directory after generation

# Changelog

## 2.1.1
- Improvements to README
- Made `out` default to `docs` and optional

## 2.1.0
- *NOTE* Changes in functionality that breaks previous versions
- Various improvements to script functionality - see above
- Dependencies bump

## 2.0.1
- Bump packages and relocated project on GitHub
npm package: @spongex/gh-sync-followers
Description: Sync GitHub Followers
Author: Matthew Evans
Latest version: 1.1.0

# Sync GitHub Followers

Sync your GitHub followers!  Automaticlly follows back any one following you, and removes people that unfollow!

Uses the [GitHub CLI](https://cli.github.com/) tool to make requests to the [GitHub API](https://docs.github.com/en/rest).

Install globally to run anywhere:
```
npm i -g @spongex/gh-sync-followers
```

For this script to run you need to grant the "user" scope to GitHub CLI.  Run the following from the command line:
```
gh auth refresh -h github.com -s user
```

Once GitHub CLI is set up run:
```
npx gh-sync-followers
```

The script will create a configuration file located in your operating system's local app storage.  This location is determined using the [os-appdata-path](https://www.npmjs.com/package/@spongex/os-appdata-path) module.

## Approvelist & Ignorelist

__To add a user or a list of users to the approved list, enter:__

```
npx gh-sync-followers approvelist <users...>
```

__To add a user or a list of users to the ignored list, enter:__

```
npx gh-sync-followers ignorelist <users...>
```

__To remove a user or group of users from the approved list, enter:__

```
npx gh-sync-followers approvelist-remove <users...>
```

__To remove a user or group of users from the ignored list, enter:__

```
npx gh-sync-followers ignorelist-remove <users...>
```

__To view either the approved or ignored lists, enter:__
```
npx gh-sync-followers approvelist-show
```

```
npx gh-sync-followers ignorelist-show
```

### Examples:
```
npx gh-sync-followers approvelist AtomicSponge otheruser
```

```
npx gh-sync-followers ignorelist-remove AtomicSponge
```

# Changelog

## 1.1.0
- Added approvelist & ignorelist features
- Bump dependencies

## 1.0.1
- Bump packages and relocated project on GitHub
- Updated project name to proper NPM formatting

## 1.0.0
 - Initial release
npm package: @spongex/godot-builder
Description: Script for building Godot projects
Author: Matthew Evans
Latest version: 1.1.0

#  Godot Builder

Script for building Godot projects.

Recommended to install as a global script:
```
npm i -g @spongex/godot-builder
```

To use create a local `.godot_builder_config.json` file in your Godot project with the following format:

```
{
  "godot_command": "godotsteam.441.editor.linux.x86_64",
  "jobs": [
    {
      "preset": "Linux",
      "path": "builds/linux/project_venus.x86_64"
    },
    {
      "preset": "Windows",
      "path": "builds/win/project_venus.exe"
    }
  ]
}
```

Then run `npx godot-builder` and allow it to complete the builds.

# Changelog

## 1.1.0
- Added --headless so it runs in Godot headless mode
- Deps bump

## 1.0.0
- Initial release
npm package: @spongex/os-appdata-path
Description: Get application storage location based on operating system
Author: Matthew Evans
Latest version: 0.2.2

#  os-appdata-path

### Get application storage location based on operating system

Will try to determine this by available global variables.
Also performs a verification that the location exists.
If a path can be found, `__os_appdata_path` will be set to its value.
If no path is found it will contain *null*.

Not tested on all OSes, but if the folder does not exist this will be *null* regardless.

If `process.env.LOCALAPPDATA` exists, then `__os_appdata_path` will be set to this value.
Otherwise, it attempts to locate by joining `process.platform` and `process.env.HOME` with common OS paths.

Example locations:
- Windows: `c:\users\username\AppData\Local`
- Mac: `/home/username/Library/Preferences`
- Linux & other OSes: `/home/username/.config`

Install to your existing project using:
```
npm i @spongex/os-appdata-path
```

Include ECMAScript:
```
import { __os_appdata_path } from '@spongex/os-appdata-path'
```

Include CommonJS:
```
const { __os_appdata_path } = require('@spongex/os-appdata-path')
```

## Usage
```

//  Make sure the value is not null
if(__os_appdata_path !== null) {
  console.log(__os_appdata_path)  //  Write it to console

  //  Use it to store some data
  fs.writeFileSync(
    path.join(__os_appdata_path, 'my-app-name', 'settings.json'),
    data
  )
}
```

# Changelog

## 0.2.2
- Dependencies bump

## 0.2.1
- README fix
- Dependencies bump

## 0.2.0
- Updatad Linux & other OSes path from `/home/username/.local/share` to `/home/username/.config`

## 0.1.0
- Initial release
npm package: @spongex/pause
Description: Pause for an amount of time
Author: Matthew Evans
Latest version: 1.0.0

#  pause

Pause for an amount of time in miliseconds

Install to your existing project using:
```
npm i @spongex/pause
```

Include ECMAScript:
```
import { pause } from '@spongex/pause'
```

Include CommonJS:
```
const { pause } = require('@spongex/pause')
```

# Usage

```
//  Pause for one second
await pause(1000)
```

# Changelog

## 1.0.0
- Initial release
npm package: @spongex/regexps
Description: Collection of regexps
Author: Matthew Evans
Latest version: 1.1.1

# regexps

### Collection of regex tests

Install to your existing project using:
```
npm i @spongex/regexps
```

Include ECMAScript:
```
import { testHexColor } from '@spongex/regexps'
```

Include CommonJS:
```
const { testAlpha } = require('@spongex/regexps')
```

# API Reference

### replaceNewlines: (str: string, replace: string) => string
Replaces newlines (\r\n, \r, \n) with another string.
Returns the modified string.
```
const resStr = replaceNewlines(oldStr, '<br/>')
```

### testHexColor: (str: string) => boolean
Test if a valid hexadecimal color value.  Allows for alpha channel.
Returns true if valid, else false.
```
const res = testHexColor('#FF00FF')
```

### testRGB: (str: string) => boolean
Test if a valid RGB(a) or HSL(a) value.
Returns true if valid, else false.
```
const res = testRGB('rgba(255, 255, 255, 0.5)')
```

### testPixel: (str: string) => boolean
Test for a valid pixel format (NNpx).
Returns true if valid, else false.
```
const res = testPixel('12px')
```

### testAlpha: (str: string) => boolean
Test if charecters are all alphabetic.
Returns true if valid, else false.
```
const res = testAlpha('ABCD')
```

### testNumeric: (str: string) => boolean
Test if charecters are all numeric.
Returns true if valid, else false.
```
const res = testNumeric('1234')
```

### testAlphaNumeric: (str: string) => boolean
Test if only alphabectic and numeric charecters.
Returns true if valid, else false.
```
const res = testAlphaNumeric('ABC123')
```

### validHex: (str: string) => boolean
Tests a string for valid hex values.
Returns true if valid, else false.
```
const res = validHex('0f9dacdc')
```

# Changelog

## 1.1.1
- Dependencies bump

## 1.1.0
- Added two new functions `replaceNewlines` and `validHex`

## 1.0.0
- Initial release
npm package: @spongex/script-error
Description: Function for handling script errors
Author: Matthew Evans
Latest version: 1.0.1

# script-error

### Function for displaying an error to console and optionally exiting
Also formats text in red

Install to your existing project using:
```
npm i @spongex/script-error
```

Include ECMAScript:
```
import { scriptError } from '@spongex/script-error'
```

Include CommonJS:
```
const { scriptError } = require('@spongex/script-error')
```

# Usage

### scriptError: (message: string, { exit?: boolean, code?: number }) => number

## Examples:

Exit script with a code of 1:
```
scriptError('Something went wrong!')
```

Don't exit script and use a custom return code:
```
scriptError('Error handler', { exit: false, code: 100 })
```

End script with a custom error code:
```
scriptError('Something bad happened!', { code: 200 })
```

# Changelog

## 1.0.1
- Dependencies bump

## 1.0.0
- Initial release
npm package: @spongex/system-locale
Description: Get the System Locale
Author: Matthew Evans
Latest version: 1.0.1

#  Sytem Locale Variable

### Get the system locale

This is a variable that will set itself to the system's locale string.

Install to your existing project using:
```
npm i @spongex/system-locale
```

Include ECMAScript:
```
import { __locale } from '@spongex/system-locale'
```

Include CommonJS:
```
const { __locale } = require('@spongex/system-locale')
```

# Usage

```
console.log(__locale)
```

Example output:  `en-US`

# Changelog

## 1.0.1
- Dependencies bump

## 1.0.0
- Initial release
npm package: @spongex/vue-encoded-message
Description: Vue Encoded Message
Author: Matthew Evans
Latest version: 1.0.1

# vue-encoded-message

Vue3 component for displaying an encoded message.  Takes UTF-16 codes and displays them on a canvas.  Useful for evading web scrapers.

Install to your existing project using:
```
npm i @spongex/vue-encoded-message
```

Include ECMAScript:
```
import { EncodedMessage } from '@spongex/vue-encoded-message'
```

Include CommonJS:
```
const { EncodedMessage } = require('@spongex/vue-encoded-message')
```

# Usage

### \<EncodedMessage :message="[189, 43, 190, 61]" :size="32"/>

#### Properties
- `message` *__(required)__* Message to display as an array of UTF-16 codes
- `size` *__(required)__* Size of the text in pixels
- `padding` *(optional)* Canvas padding in pixels
- `font-face` *(optional)* CSS Font Face value
- `font-color` *(optional)* CSS color value

# Changelog

## 1.0.1
- Dependencies bump

## 1.0.0
- Initial release
npm package: @spongex/vue-image-zoom
Description: Vue Image Zoom Component
Author: Matthew Evans
Latest version: 1.1.2

#  Vue Image Zoom

### Vue3 Component for click to zoom on images

Install to your existing project using:
```
npm i @spongex/vue-image-zoom
```

Include ECMAScript:
```
import { ImageZoom } from '@spongex/vue-image-zoom'
```

Include CommonJS:
```
const { ImageZoom } = require('@spongex/vue-image-zoom')
```

<sub>Adapted from: <https://codeconvey.com/html-image-zoom-on-click/></sub>

# Usage

### \<ImageZoom src="/img/myImage.png" width="100" caption="An example"/>

#### Properties
- `id` *(optional)* HTML Element ID
- `src` *__(required)__* URL to image source
- `alt` *(optional)* Alternate text for image
- `width` *(optional)* Width of document image
- `height` *(optional)* Height of document image
- `caption` *(optional)* Caption for modal display

# Changelog

## 1.1.2
- Dependencies bump

## 1.1.1
 - Bumped dependencies
 - Updated Vue requirements to only ^3.0.0

## 1.1.0
- Fixed maintaining aspect ratio when zooming in.
- Slight CSS improvements
- Bump Vite dev dep

## 1.0.0
- Initial release
npm package: @spontom/relaykit-js
Description: RelayKit JavaScript SDK — ship real-time video in minutes
Author: Spontom Technologies
Latest version: 0.1.1

# @spontom/relaykit-js

> RelayKit JavaScript SDK — ship real-time video in minutes

[![npm](https://img.shields.io/npm/v/@spontom/relaykit-js)](https://www.npmjs.com/package/@spontom/relaykit-js)

## Installation

```bash
npm install @spontom/relaykit-js
```

## Quick Start

```typescript
import { RelayKit } from '@spontom/relaykit-js'

const client = new RelayKit({
  apiUrl: 'https://api.relaykit.live',
  apiKey: 'rk_live_xxxx',
})

// Connect to a room
const room = await client.connect({
  roomId: 'my-room',
  participantIdentity: 'user_123',
  participantName: 'Alice',
})

// Events
room.on('participantConnected', (participant) => {})
room.on('participantDisconnected', (participant) => {})
room.on('trackSubscribed', (track, publication, participant) => {})

// Controls
await room.enableCamera()
await room.enableMicrophone()
await room.disconnect()
```

## Documentation

- [Quickstart Guide](https://relaykit.live/docs/quickstart)
- [API Reference](https://relaykit.live/docs/api-reference/rooms)
- [JavaScript SDK Docs](https://relaykit.live/docs/sdk/javascript)

## License

MIT - [Spontom Technologies](https://relaykit.live)
npm package: @spontom/relaykit-react
Description: RelayKit React SDK — hooks and components for real-time video
Author: Spontom Technologies
Latest version: 0.1.2

# @spontom/relaykit-react

> RelayKit React SDK — hooks and components for real-time video

[![npm](https://img.shields.io/npm/v/@spontom/relaykit-react)](https://www.npmjs.com/package/@spontom/relaykit-react)

## Installation

```bash
npm install @spontom/relaykit-react
```

## Quick Start

```tsx
import { RelayKitProvider, useRelayKit, useParticipants } from '@spontom/relaykit-react'

function App() {
  return (
    <RelayKitProvider apiUrl="https://api.relaykit.live" apiKey="rk_live_xxxx">
      <VideoRoom />
    </RelayKitProvider>
  )
}

function VideoRoom() {
  const { connect, disconnect, status } = useRelayKit()
  const participants = useParticipants()

  return (
    <div>
      <button onClick={() => connect({
        roomId: 'my-room',
        participantIdentity: 'user_123',
      })}>
        {status === 'connected' ? 'Leave' : 'Join'}
      </button>
      {participants.map(p => <div key={p.identity}>{p.name}</div>)}
    </div>
  )
}
```

## Hooks

| Hook | Description |
|------|-------------|
| `useRelayKit()` | Room connection, status, connect/disconnect |
| `useParticipants()` | List of remote participants |
| `useLocalCamera()` | Camera toggle and status |
| `useLocalMic()` | Microphone toggle and status |
| `useParticipantTracks(identity)` | Audio/video tracks for a participant |

## Components

| Component | Description |
|-----------|-------------|
| `<RelayKitProvider>` | Context provider for API connection |
| `<VideoTile>` | Individual participant video |
| `<AudioTile>` | Individual participant audio |
| `<ParticipantGrid>` | Auto-layout grid of all participants |
| `<ControlBar>` | Camera, mic, and leave controls |

## Documentation

- [React SDK Docs](https://relaykit.live/docs/sdk/react)
- [Quickstart Guide](https://relaykit.live/docs/quickstart)
- [API Reference](https://relaykit.live/docs/api-reference/rooms)

## License

MIT - [Spontom Technologies](https://relaykit.live)
npm package: @spooky-swap-dex/sdk-core
Description: ⚒️ An SDK for building applications on top of Spookyswap V3
Latest version: 2.0.1-nsdk004

# Uniswap SDK Core

[![npm version](https://img.shields.io/npm/v/@uniswap/sdk-core/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk-core/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk-core/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk-core@latest)

This code is shared across Uniswap TypeScript SDKs.
npm package: @spooky-swap-dex/universal-router-sdk
Description: sdk for integrating with the Universal Router contracts
Latest version: 2.0.1-nsdk004

# universal-router-sdk
This SDK facilitates interactions with the contracts in [Universal Router](https://github.com/Uniswap/universal-router)

## Usage
Install latest version of universal-router-sdk. Then import the corresponding Trade class and Data object for each protocol you'd like to interact with.

### Trading on Uniswap
warning: `swapERC20CallParameters()` to be deprecated in favor of `swapCallParameters()`
```typescript
import { TradeType } from '@uniswap/sdk-core'
import { Trade as V2TradeSDK } from '@uniswap/v2-sdk'
import { Trade as V3TradeSDK } from '@uniswap/v3-sdk'
import { MixedRouteTrade, MixedRouteSDK, Trade as RouterTrade } from '@uniswap/router-sdk'

const options = { slippageTolerance, recipient }
const routerTrade = new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_INPUT })
// Use the raw calldata and value returned to call into Universal Swap Router contracts
const { calldata, value } = SwapRouter.swapCallParameters(routerTrade, options)
```

## Running this package
Make sure you are running `node v18`
Install dependencies and run typescript unit tests
```bash
yarn install
yarn test:hardhat
```

Run forge integration tests
```bash
forge install
yarn test:forge
```
npm package: @spooky-swap-dex/v2-sdk
Description: 🛠 An SDK for building applications on top of Spookyswap V2
Latest version: 2.0.1-nsdk004

# Uniswap V2 SDK

[![npm version](https://img.shields.io/npm/v/@uniswap/v2-sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/v2-sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/v2-sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/v2-sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).