open-index/open-npm huggingface dataset:
npm package: @kagura-run/mcp
Description: MCP (Model Context Protocol) server for Kagura AI Cloud - Agentic Testing
Author: Kagura AI
Latest version: 0.1.1

# @kagura-run/mcp

MCP (Model Context Protocol) server for [Kagura AI Cloud](https://kagura.run) — Agentic Testing.

This package allows AI agents (Claude in Cursor, VS Code, etc.) to interact with your Kagura tests directly.

## Installation

### Cursor

Add to your `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "kagura": {
      "command": "npx",
      "args": ["@kagura-run/mcp"],
      "env": {
        "KAGURA_API_KEY": "kag_live_your_api_key_here"
      }
    }
  }
}
```

### VS Code

Add to your VS Code MCP settings:

```json
{
  "mcp.servers": {
    "kagura": {
      "command": "npx",
      "args": ["@kagura-run/mcp"],
      "env": {
        "KAGURA_API_KEY": "kag_live_your_api_key_here"
      }
    }
  }
}
```

### Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "kagura": {
      "command": "npx",
      "args": ["@kagura-run/mcp"],
      "env": {
        "KAGURA_API_KEY": "kag_live_your_api_key_here"
      }
    }
  }
}
```

## Getting Your API Key

1. Sign in to [Kagura Cloud](https://app.kagura.run)
2. Go to Settings → API Keys
3. Create a new API key
4. Copy the key (starts with `kag_live_`)

## Available Tools

### Tests

| Tool | Description |
|------|-------------|
| `kagura_list_tests` | List all tests (filter by published, passing, search) |
| `kagura_get_test` | Get detailed info about a specific test |
| `kagura_trigger_tests` | Trigger one or more published tests |

### Runs

| Tool | Description |
|------|-------------|
| `kagura_list_runs` | List recent test runs (filter by status) |
| `kagura_get_run_status` | Check the status of a run |
| `kagura_get_run_results` | Get detailed results of a completed run |
| `kagura_cancel_run` | Cancel a running or queued run |

### Test Groups

| Tool | Description |
|------|-------------|
| `kagura_list_test_groups` | List all test groups |
| `kagura_trigger_test_group` | Trigger all tests in a group |

### Usage

| Tool | Description |
|------|-------------|
| `kagura_get_usage` | Get credit balance and usage stats |

## Example Usage

Once configured, you can ask your AI agent things like:

- "List my published Kagura tests"
- "Run the login test"
- "Check the status of my last test run"
- "Show me my Kagura usage this month"
- "Trigger all tests in my regression group"

## Configuration Options

| Environment Variable | Description | Default |
|---------------------|-------------|---------|
| `KAGURA_API_KEY` | Your Kagura API key (required) | - |
| `KAGURA_API_URL` | Custom API URL (for self-hosted) | `https://app.kagura.run` |

## Requirements

- Node.js 18 or later
- A Kagura Cloud account with API access

## Links

- [Kagura Cloud](https://kagura.run)
- [Documentation](https://docs.kagura.run)
- [GitHub](https://github.com/Camie-Tech/kagura-oss)

## License

MIT
npm package: @kahasan/money-button
Description: Made with create-react-library
Author: kahasan
Latest version: 1.0.0

# money-button

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/money-button.svg)](https://www.npmjs.com/package/money-button) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save money-button
```

## Usage

```jsx
import React, { Component } from 'react'

import MyComponent from 'money-button'
import 'money-button/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [kahasan](https://github.com/kahasan)
npm package: @kahirokunn/prior-use-rtk-query
Description: <p align="center">   <img src="https://raw.githubusercontent.com/rtk-incubator/rtk-query/main/logo.png" width="400" /> </p>
Author: Lenz Weber
Latest version: 0.0.1

<p align="center">
  <img src="https://raw.githubusercontent.com/rtk-incubator/rtk-query/main/logo.png" width="400" />
</p>

<p align="center">
  <img src="https://img.shields.io/badge/ALPHA-pre%20release-orange">
   <a href="https://discord.gg/0ZcbPKXt5bZ6au5t" target="_blank">
    <img src="https://img.shields.io/badge/chat-online-green" alt="Discord server" />
  </a>
</p>

## Introduction

RTK Query is an advanced data fetching and caching tool, designed to simplify common cases for loading data in a web application. It is built on top of [Redux Toolkit](https://redux-toolkit.js.org/) and uses Redux internally for its architecture.

It features:

- Declarative API definitions
- Runs on every framework
- Supports any protocol
- Caching
- Automatic re-fetching
- Polling
- Parallel queries
- Dependent queries
- Paginated queries
- Skip queries
- Lagged queries
- Automatic garbage collection
- Prefetching
- Optimistic Updates
- Auto-generated React Hooks
- Built with TypeScript

... and plenty of other goodies.

## Getting started

```sh title="Example installation"
yarn add @rtk-incubator/rtk-query @reduxjs/toolkit
```

Or with npm:

```sh
npm install @rtk-incubator/rtk-query @reduxjs/toolkit
```

Then follow along with the [Getting Started instructions](https://rtk-query-docs.netlify.app/introduction/getting-started).

## Documentation

[View the RTK Query docs](https://rtk-query-docs.netlify.app/)

## Examples

[View the examples](https://rtk-query-docs.netlify.app/examples/examples-overview)
npm package: @kahirokunn/snake-case-keys
Description: type safe snake case keys.
Author: kahirokunn
Latest version: 0.0.5

## Install

Install with npm:

```sh
$ npm install --save @kahirokunn/snake-case-keys
```

Install with yarn:

```sh
$ yarn add @kahirokunn/snake-case-keys
```

## snakecaseKeys Usage

```typescript
import { shallowSnakeCaseKeys, deepSnakeCaseKeys } from '@kahirokunn/snake-case-keys';

a = {
  helloWorld: {
    ohMyGod: {
      soCrazy: 'hello',
      sorryMan: 0.8989,
    },
    okGood: {
      yeah: 3232,
    },
  },
  _goodbuyWorld: {
    finish: 'world',
  }
}

shallowSnakeCaseKeys(a);
/*
return
{
  hello_world: {
    ohMyGod: {
      soCrazy: "hello",
      sorryMan: 0.8989
    },
    okGood: {
      yeah: 3232
    }
  },
  _goodbuy_world: {
    finish: "world"
  }
}
*/

deepSnakeCaseKeys(a);
/*
return
{
  hello_world: {
    oh_my_god: {
      so_crazy: "hello",
      sorry_man: 0.8989
    },
    ok_good: {
      yeah: 3232
    }
  },
  goodbuy_world: {
    finish: "world"
  }
}
*/
```
npm package: @kahirokunn/ts-concat
Description: type safe curry.
Author: kahirokunn
Latest version: 1.0.0

## Install

Install with npm:

```sh
$ npm install --save ts-concat
```

Install with yarn:

```sh
$ yarn add ts-concat
```

## Spec

```typescript
import { concat } from 'ts-concat';

test('basic 1', () => {
  const a = [1, 2, 3, 4] as const
  const b = [5, 6, 7, 8] as const
  const c = concat(a, b);
  const d: [1, 2, 3, 4, 5, 6, 7, 8] = c

  expect(d).toStrictEqual([...a, ...b]);
});

test('basic 2', () => {
  const a = [1, 2, 3, 4] as const
  const b: string[] = ['hello', 'world']
  const c = concat(a, b);
  const d: [1, 2, 3, 4, ...string[]] = c

  expect(d).toStrictEqual([...a, ...b]);
});

test('basic 3', () => {
  const a: string[] = ['hello', 'world']
  const b = [5, 6, 7, 8] as const
  const c = concat(a, b);
  const d: (string | 5 | 6 | 7 | 8)[] = c

  expect(d).toStrictEqual([...a, ...b]);
});
```
npm package: @kahirokunn/ts-curry
Description: type safe curry.
Author: kahirokunn
Latest version: 1.0.3

## Install

Install with npm:

```sh
$ npm install --save @kahirokunn/ts-curry
```

Install with yarn:

```sh
$ yarn add @kahirokunn/ts-curry
```

## Spec

```typescript
import { curry } from '@kahirokunn/ts-curry';

test('curryable', () => {
  function curryable(
    a: number,
    b: string,
    c: `${string}-${string}`,
  ) {
    return '1/2/3';
  }

  const f = curry(curryable);
  const b = f(1);
  const c = b('hello');
  const d = c('1-2');

  expect(d).toBe('1/2/3');
});

test('partial application', () => {
  const add = curry((a: number, b: number) => a + b);
  const add5 = add(5);

  expect(add(0)(0)).toBe(0);
  expect(add(1)(0)).toBe(1);
  expect(add5(5)).toBe(10);
  expect(add5(10)).toBe(15);
  expect(add5(-5)).toBe(0);
});

class BindDog {
  constructor(private readonly sound: string) {
    this.say = this.say.bind(this)
  }

  say(a: string, b: string, c: string) {
    return `${this.sound}${a}${b}${c}`
  }
}

class UnbindDog {
  constructor(private readonly sound: string) {}

  say(a: string, b: string, c: string) {
    return `${this.sound}${a}${b}${c}`
  }
}

test('bind class method', () => {
  const dog = new BindDog('h')
  expect(dog.say('e', 'l', 'l')).toBe('hell');

  const say = dog.say
  expect(say('e', 'l', 'l')).toBe('hell');

  const f = curry(dog.say, dog);
  const a = f('e')
  const b = a('l')
  const c = b('l')

  expect(c).toBe('hell');
});

test('unbind class method', () => {
  const dog = new UnbindDog('h')
  expect(dog.say('e', 'l', 'l')).toBe('hell');

  // should pass context to 2nd args
  const f = curry(dog.say, dog);
  const a = f('e')
  const b = a('l')
  const c = b('l')

  expect(c).toBe('hell');
});

function assertsNever<T extends never>(v: T) {}

test('not curryable because variable argument', () => {
  function notCurryable(
    a: number,
    ...d: string[]
  ): `${string}/${string}/${string}` {
    return '1/2/3';
  }

  const f = curry(notCurryable);
  assertsNever(f);
});
```
npm package: @kahirokunn/vue-type-check
Description: a type checker for typescript written Vue components
Author: yanzhen@smartx.com
Latest version: 1.0.0

<p align="center">
  <img width="100px" height="100px" src="https://raw.githubusercontent.com/Yuyz0112/vue-type-check/master/assets/logo.png">
</p>

# vue-type-check

vue-type-check is a type checker for typescript written Vue components.

It provides both a CLI wrapper and a programmatically API which is easy to integrate with your current workflow.

## Features

- type checking template code.
- type checking script code.

## Usage

### CLI

```shell
Install: npm i -g vue-type-check

Usage: vue-type-check or vtc
Options:
  --workspace        path to your workspace, required
  --srcDir           path to the folder which contains your Vue components, will fallback to the workspace when not passed
  --onlyTemplate     whether to check the script code in a single file component
```

#### Example

We are going to check a simple Vue component with two type errors:

```vue
<template>
  <div id="app">
    <p>{{ msg }}</p>
  </div>
</template>

<script lang="ts">
import Vue from "vue";

export default Vue.extend({
  name: "app",
  data() {
    return {
      message: "Hello World!"
    };
  },
  methods: {
    printMessage() {
      console.log(this.message.toFixed(1));
    }
  }
});
</script>
```

![example.gif](https://raw.githubusercontent.com/Yuyz0112/vue-type-check/master/assets/vtc.gif)

### Programmatical API

```js
const { check } = require("vue-type-check");

(async () => {
  await check({
    workspace: PATH_TO_WORKSPACE,
    srcDir: PATH_TO_SRC_DIR,
    excludeDir: PATH_TO_EXCLUDE_DIR,
    onlyTemplate: TRUE_OR_FALSE,
    onlyTypeScript: TRUE_OR_FALSE
  });
})();
```

## How it works

Currently, the implementation is heavily based on vetur's awesome [interpolation feature](https://vuejs.github.io/vetur/interpolation.html).

If you are interested in the design decisions and the attempts on other approaches, they can be found in [this post](http://www.myriptide.com/vue-type-check/).
npm package: @kahirokunn/vuedts
Description: Generate TypeScript declaration files for .vue files
Author: kahirokunn
Latest version: 1.3.4

# vuedts

This repository is fork from https://github.com/ktsn/vuetype
Because that repository has not maintained now.

[![npm version](https://badge.fury.io/js/vuedts.svg)](https://badge.fury.io/js/vuedts)
[![Build Status](https://travis-ci.org/kahirokunn/vuedts.svg?branch=master)](https://travis-ci.org/kahirokunn/vuedts)

Generate TypeScript declaration files for .vue files

## Sample Repository

https://github.com/kahirokunn/book-management/pull/75

## Installation

You can use `vuedts` command after exec one of following commands.

```bash
$ npm install --global @kahirokunn/vuedts # npm
$ yarn global add @kahirokunn/vuedts # yarn
```

## Usage

Specify the directory that includes your `.vue` files as the 2nd argument of `vuedts` command. Note that the `.vue` files should have TypeScript code (in `<script lang="ts">` element).

```bash
vuedts src/components
```

Then `.vue.d.ts` file corresponding `.vue` file will be output. So you can import each `.vue` component with concrete type declaration! This would help your editor inspect.

For example, if there is the following component:

```html
<template>
  <div>{{ message }}</div>
</template>

<script lang="ts">
import Vue from 'vue'
import Component from 'vue-class-component'

@Component
export default class MyComp extends Vue {
  message = 'Hello'
}
</script>
```

You will acquire the following declaration file:

```ts
import Vue from 'vue';
export default class MyComp extends Vue {
    message: string;
}
```

### Watch mode

You can enable watch mode by adding `--watch` (shorthand `-w`) flag. In the watch mode, vuedts watches update of `.vue` files and generates declaration files when the `.vue` files are updated.

```bash
vuedts --watch src/components
```

## License

MIT
npm package: @kahless/echolot
Description: This package is deprecated in favor of [Introversion.js](https://github.com/GeneZharov/introversion)
Author: Yevgeny Zharov
Latest version: 0.0.5
Deprecated: Use 'introversion' package instead

This package is deprecated in favor of [Introversion.js](https://github.com/GeneZharov/introversion)
npm package: @kahlil/blog-cli
Description: A cli to create blog posts for static site generators.
Author: Kahlil Lechelt
Latest version: 1.0.5

# blog-cli

> A cli to create blog posts for static site generators.

This is a useful little helper if you have a Jekyll, Hugo or any other
static site generator blog that consumes Markdown files with Front Matter.

Once you configure it with the path to your Markdown files and your favorite Markdown editor
it will create Markdown files for you blog posts in that directory with the following Front Matter:

```
---
draft: true
date: 2019-01-17T09:34:49.212Z
title: ""
---
```

If you are publishing your blog by pushing to a remote Git repository you can use the
`--publish` flag to publish your blog. It will add all unstaged files, commit them with the message
`new post` and push to origin master.

## Install

```
$ npm install --global @kahlil/blog-cli
```

## Usage

```
Usage
	$ blog [slug]

Options
	--help
	--path  ~/path/to/posts [Default: .]
	--editor 'visual studio code' [Default: 'ia writer']
	--publish [Default: true]

Examples
	$ blog --path ~/my-blog/posts
	Saved the path `~/my-blog/posts` for your blog posts

	$ blog --editor '	visual studio code'
	Saved visual studio code as your editor

	$ blog my-cool-post
	Created your new post at
	/Users/username/my-blog/posts/2019-01-17-my-cool-post.md
	and openening it in your editor

	$ blog --publish
	Your changes have been pushed
```

## License

MIT © [Kahlil Lechelt](http://kahlillechelt.com)
npm package: @kahlil/flow-state
Description: A simple Redux-type library entirely based on RxJS streams. This is an easy way to introduce a stream-based unidirectional dataflow into your app.
Author: Kahlil Lechelt
Latest version: 10.0.1

# FlowState 🌊

Dead simple Redux and redux-observable library built with RxJS streams. This is an easy way to introduce a stream-based unidirectional dataflow into your app.

## Highlights

- Inspired by Redux and redux-observable
- The state is delivered with streams
- Reducers are just functions, no switch-case
- Isolate side effects that map back to actions

## Install

`npm install @kahlil/flow-state`

## Usage

```js
import { createFlowState } from '@kahlil/flow-state';

const flowState = createFlowState();
```

### Dispatch Actions
In your components dispatch actions by passing the action constant and optionally
an action payload. The payload can be any value.

```js
flowState.dispatch({ type: 'SOME_ACTION', payload: { some: 'state' } });
```

### Create A State Stream Based On Reducers
In a file that you could call Store,
create and expose state streams for your components
by passing the respective reducers.

Here is also the place where you can combine state streams if they
depend on one another.

```js
// A collection of reducers.
const itemListReducers = {
  deleteItem: (action, state) => state
    .filter(item => state.filter(item.id !== action.payload.id)),
    
  addItem: (action, state) => [...state, action.payload],
  // ...
};

itemListState$ = flowState.createState$(itemListReducers, initialState);
```

In your component you can now subscribe to the component state stream: 

```js
itemListState$.subscribe(state => console.log(state));
```

### Trigger Side Effects
You can trigger your side effects similar to redux-observable 
by listening to the actions stream, triggering your side effect 
and return a new action.

Each side effect is a function and has to be passed to 
`flowState.runSideEffects`. 

The action that the result of each side effect maps to

```js
// An imaginary API.
const serverApi = new serverApi();
const action$ = flowState.getAction$();

const sideEffect1 = action$ => action$
  .filter(action => action.type === 'DELETE_ITEM')
  .switchMap(action => serverApi.deleteItem(action.payload))
  .map(response => ({ type: 'RECEIVE_ITEMS', payload: response }))
  .catch(response => ({ type: 'DELETE_ITEM_ERROR', payload: response.error });

const sideEffect1 = action$ => action$
  .filter(action => action.type === 'ADD_ITEM')
  .switchMap(action => serverApi.addItem(action.payload))
  .map(response => ({ type: 'RECEIVE_ITEMS', payload: response }))
  .catch(response => ({ type: 'ADD_ITEM_ERROR', payload: response.error });

flowState.runSideEffects(sideEffect1, sideEffect2);
```

## License

MIT © [Kahlil Lechelt](http://kahlil.info)