open-index/open-npm huggingface dataset:
npm package: @getkist/action-eslint
Description: ESLint linting actions for kist
Author: kist
Latest version: 1.0.8

# @getkist/action-eslint

ESLint linting actions for kist.

## Installation

```bash
npm install @getkist/action-eslint
```

## Usage

### As a kist plugin

```yaml
# kist.yml
plugins:
  - "@getkist/action-eslint"

pipeline:
  - action: LintAction
    options:
      targetFiles:
        - "src/**/*.ts"
        - "src/**/*.js"
      fix: false
      configPath: "eslint.config.js"
```

### Standalone usage

```typescript
import { LintAction } from "@getkist/action-eslint";

const action = new LintAction();
await action.execute({
  targetFiles: ["src/**/*.ts"],
  fix: true,
  configPath: "eslint.config.js"
});
```

## Actions

### LintAction

Runs ESLint on specified files and directories, with optional auto-fixing.

#### Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `targetFiles` | `string[]` | `["src/**/*.ts"]` | Files or glob patterns to lint |
| `fix` | `boolean` | `false` | Whether to automatically fix issues |
| `configPath` | `string` | `"eslint.config.js"` | Path to ESLint config file |

## Configuration Examples

### Lint TypeScript and JavaScript files

```yaml
- action: LintAction
  options:
    targetFiles:
      - "src/**/*.ts"
      - "src/**/*.tsx"
      - "src/**/*.js"
      - "src/**/*.jsx"
```

### Auto-fix issues

```yaml
- action: LintAction
  options:
    targetFiles:
      - "src/**/*.ts"
    fix: true
```

### Use custom config

```yaml
- action: LintAction
  options:
    targetFiles:
      - "src/**/*.ts"
    configPath: "config/eslint.custom.js"
```

## License

MIT
npm package: @getkist/action-terser
Description: JavaScript minification actions for kist using Terser
Author: kist
Latest version: 1.0.6

# @getkist/action-terser

JavaScript minification actions for kist using Terser.

## Installation

```bash
npm install @getkist/action-terser
```

## Usage

### As a kist plugin

```yaml
# kist.yml
plugins:
  - "@getkist/action-terser"

pipeline:
  - action: JavaScriptMinifyAction
    options:
      inputPath: "src/app.js"
      outputPath: "dist/app.min.js"
```

### Standalone usage

```typescript
import { JavaScriptMinifyAction } from "@getkist/action-terser";

const action = new JavaScriptMinifyAction();
await action.execute({
  inputPath: "src/app.js",
  outputPath: "dist/app.min.js",
  customConfig: {
    compress: {
      drop_console: false
    }
  }
});
```

## Actions

### JavaScriptMinifyAction

Minifies JavaScript files using Terser to reduce file size and optimize performance.

#### Options

| Option | Type | Required | Description |
|--------|------|----------|-------------|
| `inputPath` | `string` | Yes | Path to the input JavaScript file |
| `outputPath` | `string` | Yes | Path where the minified file will be saved |
| `customConfig` | `object` | No | Custom Terser configuration to merge with defaults |

#### Default Terser Configuration

The action uses sensible defaults optimized for production:

- **Compression**: Drops console statements, removes debugger, dead code elimination
- **Mangling**: Minifies variable and function names
- **Output**: Removes comments, no beautification
- **ECMAScript**: Targets ES5 for broad compatibility

You can override any Terser option via `customConfig`.

## Configuration Examples

### Preserve console.log statements

```yaml
- action: JavaScriptMinifyAction
  options:
    inputPath: "src/app.js"
    outputPath: "dist/app.min.js"
    customConfig:
      compress:
        drop_console: false
```

### Generate source maps

```yaml
- action: JavaScriptMinifyAction
  options:
    inputPath: "src/app.js"
    outputPath: "dist/app.min.js"
    customConfig:
      sourceMap:
        filename: "app.min.js.map"
        url: "app.min.js.map"
```

### Target modern browsers (ES2020)

```yaml
- action: JavaScriptMinifyAction
  options:
    inputPath: "src/app.js"
    outputPath: "dist/app.min.js"
    customConfig:
      ecma: 2020
      module: true
```

## License

MIT
npm package: @getkist/action-test
Description: Test harness actions for validating kist action plugins
Author: kist
Latest version: 1.1.4

# @getkist/action-test

[![npm version](https://img.shields.io/npm/v/@getkist/action-test.svg)](https://www.npmjs.com/package/@getkist/action-test)
[![npm downloads](https://img.shields.io/npm/dm/@getkist/action-test.svg)](https://www.npmjs.com/package/@getkist/action-test)
[![Node.js version](https://img.shields.io/node/v/@getkist/action-test.svg)](https://nodejs.org/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Test Status](https://github.com/getkist/kist-action-test/workflows/Test/badge.svg)](https://github.com/getkist/kist-action-test/actions)
[![CodeQL Status](https://github.com/getkist/kist-action-test/workflows/CodeQL/badge.svg)](https://github.com/getkist/kist-action-test/actions)
[![Codecov Coverage](https://img.shields.io/codecov/c/github/getkist/action-test.svg)](https://codecov.io/gh/getkist/action-test)

Test harness actions for validating kist action plugins.

## Features

- 🧪 Lightweight action to verify plugin loading and execution
- ⏱️ Optional delay to simulate work
- 🔄 Repeat logging to shape output
- 📊 Configurable log levels (info, warn, error)
- 💾 Write run metadata and payloads to JSON files
- ❌ Forced failure mode for testing error handling

## Installation

```bash
npm install --save-dev @getkist/action-test
```

## Quick Start

```yaml
pipeline:
    stages:
        - name: test
          steps:
              - name: smoke-test
                action: TestHarnessAction
                options:
                    message: "plugin loaded successfully"
```

## Documentation

- **[Usage Guide](./doc/usage.md)** - YAML and programmatic examples
- **[Configuration](./doc/configuration.md)** - All available options
- **[Examples](./doc/examples.md)** - Real-world test scenarios
- **[API Reference](./doc/api.md)** - Generated TypeDoc documentation
- **[Troubleshooting](./doc/troubleshooting.md)** - Common issues and solutions
- **[Performance Guide](./doc/performance.md)** - Tips for optimization

## Actions

### TestHarnessAction

Lightweight test action for validating plugin behavior.

**Options:**

- `message` (string, optional) - Log message
- `shouldFail` (boolean, optional) - Throw when true
- `delayMs` (number, optional) - Delay before finishing (ms)
- `repeat` (number, optional) - Repeat message N times
- `logLevel` (info|warn|error, optional) - Logging severity
- `outputPath` (string, optional) - JSON file for metadata
- `payload` (object, optional) - Extra data to write

## Development

```bash
npm run build        # Compile TypeScript
npm run test         # Run tests
npm run lint         # Check code quality
npm run docs         # Generate API documentation
npm run format       # Format code with Prettier
```

## License

MIT
npm package: @getkist/action-tsup
Description: TypeScript bundling actions for kist using tsup
Author: kist
Latest version: 1.0.7

# @getkist/action-tsup

TypeScript bundling actions for kist using tsup (powered by esbuild).

## Installation

```bash
npm install @getkist/action-tsup
```

## Usage

### As a kist plugin

```yaml
# kist.yml
plugins:
  - "@getkist/action-tsup"

pipeline:
  - action: BundleAction
    options:
      entry: "src/index.ts"
      outDir: "dist"
      format: ["esm", "cjs"]
      dts: true
```

### Standalone usage

```typescript
import { BundleAction } from "@getkist/action-tsup";

const action = new BundleAction();
await action.execute({
  entry: "src/index.ts",
  outDir: "dist",
  format: ["esm", "cjs"],
  dts: true,
  minify: true,
  sourcemap: true
});
```

## Actions

### BundleAction

Bundles TypeScript/JavaScript files using tsup (powered by esbuild).

#### Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `entry` | `string \| string[] \| Record<string, string>` | *required* | Entry point(s) for the bundle |
| `outDir` | `string` | `"dist"` | Output directory |
| `format` | `"esm" \| "cjs" \| "iife" \| Array` | `"esm"` | Output format(s) |
| `dts` | `boolean` | `true` | Generate TypeScript declaration files |
| `sourcemap` | `boolean` | `false` | Generate sourcemaps |
| `minify` | `boolean` | `false` | Minify output |
| `clean` | `boolean` | `true` | Clean output directory before build |
| `splitting` | `boolean` | `false` | Split code into chunks |
| `target` | `string` | `"node20"` | Target environment |
| `external` | `string[]` | `[]` | External packages to exclude |
| `configPath` | `string` | - | Path to tsup config file |
| `tsupOptions` | `object` | `{}` | Additional tsup options |

## Configuration Examples

### Multiple entry points

```yaml
- action: BundleAction
  options:
    entry:
      main: "src/index.ts"
      cli: "src/cli.ts"
    outDir: "dist"
    format: ["esm", "cjs"]
```

### Browser bundle (IIFE)

```yaml
- action: BundleAction
  options:
    entry: "src/browser.ts"
    outDir: "dist"
    format: "iife"
    minify: true
    target: "es2020"
```

### Library with sourcemaps

```yaml
- action: BundleAction
  options:
    entry: "src/index.ts"
    format: ["esm", "cjs"]
    dts: true
    sourcemap: true
    external:
      - "react"
      - "react-dom"
```

### Code splitting for ESM

```yaml
- action: BundleAction
  options:
    entry:
      - "src/index.ts"
      - "src/utils.ts"
    format: "esm"
    splitting: true
```

## License

MIT
npm package: @getkit/tools
Description: This is a set of tools for the GetKit project. It includes scripts for viewing settings, managing workspaces, and more.
Author: Anson C
Latest version: 0.0.5

# @getkit/tools

This is a set of tools for the GetKit project. It includes scripts for viewing settings, managing workspaces, and more.

## Installation

1. Clone the repository: `git clone https://github.com/Ansonhkg/getkit`
2. Install the dependencies `bun install`

## Usage

Run a command via npx, like "npx getkit/tools workspaces". The "workspaces" command refers to the one defined in package.json.
npm package: @getkoala/crc32
Description: Tiny implementation of CRC32
Author: Netto Farah
Latest version: 0.1.1

# CRC32
A tiny implementation of the CRC32 algorithm in JavaScript

## Usage

```bash
$ npm install --save @koala-live/crc32
```

```javascript
import { crc32 } from '@koala-live/crc32'

crc32('koala 🐨') // 4005375993
```
npm package: @getkoala/react
Description: React hooks for integrating Koala.
Author: Matthew Shwery
Latest version: 2.1.1

# @getkoala/react

Koala SDK hooks for React.

## Install

```sh
yarn add @getkoala/react

# install peer dependencies if not already installed
yarn add react react-dom
```

## Recommended Usage

```tsx
import React from "react";
import ReactDOM from "react-dom";
import ko from "@getkoala/react";

// Load the Koala SDK immediately
ko.init("<your Koala public API key>");

function App() {
  const [ready, setReady] = React.useState(false);

  // Pseudocode to exemplify getting the logged-in user
  const user = useCurrentUser();

  React.useEffect(() => {
    if (user) {
      ko.identify(user.email, { name: user.name });
    }
  }, [user]);

  React.useEffect(() => {
    ko.ready(() => setReady(true));
  }, []);

  return <div>{ready ? "Ready" : "Loading"}</div>;
}

ReactDOM.render(
  <App />
  document.getElementById("root")
);
```

## Alternative usage

You can also use KoalaProvider to load the SDK and the useKoala hook if necessary, though you should be able to do everything you need using the recommended usage instead.

```tsx
import React from "react";
import ReactDOM from "react-dom";
import { KoalaProvider, useKoala } from "@getkoala/react";

function App() {
  // You can start using `koala` immediately, but it will asynchronously
  // load in the background. The `ready` flag will indicate when it has
  // it has loaded, if you need to do something after.
  // While loading, `koala` will buffer method calls and execute them
  // after it has finished loaded.
  const { koala, ready } = useKoala();

  // Pseudocode to exemplify getting the logged-in user
  const user = useCurrentUser();

  React.useEffect(() => {
    if (user) {
      koala.identify({ email: user.email, name: user.name });
    }
  }, [koala, user]);

  return <div>{ready ? "Ready" : "Loading"}</div>;
}

ReactDOM.render(
  <KoalaProvider publicApiKey="<your Koala public API key>">
    <App />
  </KoalaProvider>,
  document.getElementById("root")
);
```
npm package: @getlago/passport-intercom
Description: Intercom authentication strategy for Passport.
Author: Intercom
Latest version: 0.0.5

# Passport Intercom

[Passport](https://github.com/jaredhanson/passport) strategy for authenticating
with [Intercom](http://intercom.io/) using the OAuth 2.0 API.

This module lets you authenticate using Intercom in your Node.js applications.
By plugging into Passport, Intercom authentication can be easily and
unobtrusively integrated into any application or framework that supports
[Connect](http://www.senchalabs.org/connect/)-style middleware, including
[Express](http://expressjs.com/).

[Example Application](https://github.com/intercom/passport-intercom-example-app)

## Install

```js
$ npm install passport-intercom
```

[NPM package](https://www.npmjs.com/package/passport-intercom)

## Usage

#### Configure Strategy

The Intercom authentication strategy authenticates users using a Intercom
account and OAuth 2.0 tokens.  The strategy requires a `verify` callback, which
accepts these credentials and calls `done` providing a user, as well as
`options` specifying a client ID, client secret, and callback URL.

```js
passport.use(new IntercomStrategy({
    clientID: INTERCOM_CLIENT_ID,
    clientSecret: INTERCOM_CLIENT_SECRET,
    callbackURL: "http://localhost:3000/auth/intercom/callback"
  },
  function(accessToken, refreshToken, profile, done) {
    User.findOrCreate({ intercomAdminId: profile.id }, function (err, user) {
      return done(err, user);
    });
  }
));
```

#### Authenticate Requests

Use `passport.authenticate()`, specifying the `'intercom'` strategy, to
authenticate requests.

For example, as route middleware in an [Express](http://expressjs.com/)
application:

```js
app.get('/auth/intercom',
  passport.authenticate('intercom'));

app.get('/auth/intercom/callback',
  passport.authenticate('intercom', { failureRedirect: '/login' }),
  function(req, res) {
    // Successful authentication, redirect home.
    res.redirect('/');
  });
```

## Examples

For a complete, working example, refer to [passport-intercom-example-app](https://github.com/intercom/passport-intercom-example-app).

## Tests

```bash
$ npm install --dev
$ make test
```

## Credits

Inspired by [Jared Hanson](http://github.com/jaredhanson)'s passport plugins.

## License

[The MIT License](http://opensource.org/licenses/MIT)