open-index/open-npm huggingface dataset:
npm package: @mok-labs/locales-check
Description: Checks missing keys in your locales files
Author: moklabs
Latest version: 1.1.0

README
# @mok-labs/locales-check

`@mok-labs/locales-check` is a tiny library designed to identify discrepancies between your locale files by detecting missing keys. It analyzes the combined structure of all your locale files and provides a report on any absent keys. Currently, the library supports only JSON files, which must be stored in the same locales directory.

## Content
- [Why?](#why)
- [Usage](#usage)
- [Configuration](#configuration)
- [License](#license)

## Why?
When we incorporated multiple languages into our projects, managing consistent keys across all language files became a challenge. Often, some keys were overlooked, and even code reviews occasionally failed to catch these omissions. To address this issue, we implemented this small library to then use it as a check in our Continuous Integration (CI) workflow to identify any missing keys in our locale files.


## Usage 

Install the package in your project:

With npm

```sh
npm install --save-dev @mok-labs/locales-check
```
With yarn
```sh
yarn add -D @mok-labs/locales-check
```


Use it via script in your `package.json` file:

```json
{
  "scripts": {
    "locales-check": "npx @mok-labs/locales-check --localesPath='./path/to/locales-files/'"
  }
}
```

## Configuration
### `localesPath`

* Name: `localesPath`
* CLI argument: `--localesPath`
* Required: Yes
* Type: `string`
* Description: The path where your locales files are placed
* Examples: `./path/to/locales-files`

### `ci`

* Name: `ci`
* CLI argument: `--ci`
* Required: No
* Default: `false`
* Type: `boolean`
* Description: Causes the process to exit with exit code 1 if at least one translation key is missing or unused (useful if it is part of a CI pipeline).

## Contributing

Before getting started, please review our [Contribution Guide](CONTRIBUTING.md) to ensure a smooth collaboration.

## Changelog

Stay updated with the latest changes and improvements by checking out our [Changelog](CHANGELOG.md). 

## License

[MIT](LICENSE.md)
npm package: @moka-fe/benchmark-webpack-plugin
Description: A webpack plugin used to collect benchmark data
Author: lishunyang
Latest version: 1.0.9

benchmark-webpack-plugin
========================

A webpack plugin which is used for benchmark😑

## Usage

1. Install package

```sh
npm i --save-dev @moka-fe/benchmark-webpack-plugin
```

2. Modify webpack config

```js
const BenchmarkWebpackPlugin = require('@moka-fe/benchmark-webpack-plugin');

...

module.exports = {
  plugins: [
    new BenchmarkWebpackPlugin(),
  ],
}
```

3. Build & upload data

Everytime when you start webpack and build project, the plugin will collect data and send them to a benchmark billboard, click [here](https://benchmark.lishunyang.com).
npm package: @moka1177/mountebank-manager
Description: A manager for mountebank test doubles
Author: Oscar Pinto
Latest version: 0.2.0

# MounteBank Manager

A small TypeScript library to manage Mountebank test doubles. Packaged as `@moka1177/mountebank-manager` and built to `dist`.

## Overview

MounteBank Manager provides a programmatic interface to start/stop a local Mountebank server and create, delete, or clear imposters for HTTP testing. It is written in TypeScript and tested with Jest.

## Installation

Install from npm:

```bash
npm install @moka1177/mountebank-manager
```
Usage
Example (TypeScript):

```typescript
import { mounteBankManager } from '@moka1177/mountebank-manager';

async function run() {
await mounteBankManager.startMountebank();
     const stub = buildStub(
        '/foo/bar',
        'POST',
        JSON.stringify({
            data: {
                foo: 'bar'
            }
        }),
        200
    );
    const otherStub = buildStub(
        '/bar/foo',
        'POST',
        JSON.stringify({
            data: {
                foo: 'none'
            }
        }),
        500
    );

const stubs = [stub, otherStub];
await mounteBankManager.createImposter(stubs, '4545');
// run tests against http://localhost:4545
await mounteBankManager.stopMountebank();
}

run();
```
Public API (high level)
startMountebank(): Promise<void> — starts Mountebank process.
createImposter(stubs, servicePort: string): Promise<any> — posts a new imposter.
deleteImposter(servicePort: string): Promise<void> — deletes a specific imposter.
clearAllImposters(): Promise<void> — removes all imposters.
stopMountebank(): Promise<void> — clears imposters and stops Mountebank.
npm package: @mokahr/cache-manage-plugin
Description: A webpack plugin used to mange muilti dependencies loader/plugin cache
Author: wYuanHpp
Latest version: 1.0.2

# cache-manage-plugin

A Webpack plugin used to manage multiply cache Directory.

Manage different code caches based on the hash.


## Usage

1. Install dependency.

`npm install --save-dev @mokahr/cache-manage-plugin`

2. Update webpack config file.

```js
const CacheManage = require('@mokahr/cache-manage-plugin');

const someHash = createHash();
// your webpack config
module.exports = {
  module: {
    rules: [
      {
        loader: 'babel-loader',
        options: {
          cacheDirectory: `node_modules/.cache/babel-loader/${someHash}`,
        },
      },
    ]
  }
  ...
  plugins: [
    ...
    new CacheManage({    // use
      cacheHash: someHash, 
      dependencyCachePaths: [`node_modules/.cache/babel-loader/${someHash}`],
    }), 
  ]
}
```

## Configuration

```js
new CacheManage(options)
```

### [optional] options.cacheRecordPath: string

cache directory, default value is `node_modules/.cache`

### [required] options.cacheHash: string

cacheHash mast  provide;

### [optional] options.maxAge: number

cache max age,  default value is `1 * 24 * 60 * 60 * 1000` one day

### [optional] options.dependencyCachePaths: 

need to manage cache's cacheDirectory list, default value is `[]`
npm package: @mokahr/unused-webpack-plugin
Description: A webpack plugin used to find unused source files
Author: lishunyang
Latest version: 1.0.7

# unused-webpack-plugin

A Webpack plugin used to find unused source files


## Usage

1. Install dependency.

`npm install --save-dev @mokahr/unused-webpack-plugin`

2. Update webpack config file.

```js
const UnusedWebpackPlugin = require('@mokahr/unused-webpack-plugin');

// your webpack config
module.exports = {
  ...
  plugins: [
    ...
    new UnusedWebpackPlugin(), // use the 'unused' plugin ;-)
  ]
}
```

3. Restart your webpack server and a new file named `unused-files` will be created under the project working directory.

## Configuration

```js
new UnusedWebpackPlugin(options)
```

### [optional] options.cwd: string

Current working directory, default value is `./`

### [optional] options.patterns: string[]

Included glob pattern list, default value is `['**/*.js', '**/*.styl']`, which means only .js or .styl files will be checked.

Note: Usually not all the static assets are referenced in js files directly, such as some images or font files, therefore we do not recommend to use the pattern `*` directly, otherwise you may got some misleading results.

### [optional] options.ignores: string[]

Excluded glob pattern list, default value is `['node_modules/**']`

### [optional] options.output: string

The result file path, default value is `./unused-files`

## Tips

- Please do not use this plugin on production environment.
- After generating unused files, you can remove them by shell command `cat unused-files | while read LINE; do rm $LINE; done`.
npm package: @mokei/anthropic-provider
Description: Mokei Anthropic provider
Latest version: 0.6.0

# @mokei/anthropic-provider

Anthropic Claude provider for Mokei.

## Installation

```bash
npm install @mokei/anthropic-provider
```

## Usage

### Basic Chat

```typescript
import { AnthropicProvider } from '@mokei/anthropic-provider'

const provider = AnthropicProvider.fromConfig({
  apiKey: process.env.ANTHROPIC_API_KEY,
})

// List available models
const models = await provider.listModels()
console.log(models)

// Stream a chat completion
const request = provider.streamChat({
  model: 'claude-sonnet-4-20250514',
  messages: [
    { source: 'client', role: 'user', text: 'Hello, Claude!' }
  ],
})

for await (const stream of await request) {
  const reader = stream.getReader()
  while (true) {
    const { done, value } = await reader.read()
    if (done) break
    if (value.type === 'text-delta') {
      process.stdout.write(value.text)
    }
  }
}
```

### With Tool Calling

```typescript
import { AnthropicProvider } from '@mokei/anthropic-provider'
import { ContextHost } from '@mokei/host'
import { AgentSession } from '@mokei/session'

const provider = AnthropicProvider.fromConfig({
  apiKey: process.env.ANTHROPIC_API_KEY,
})

const host = new ContextHost()
// ... add MCP contexts

const agent = new AgentSession({
  provider,
  model: 'claude-sonnet-4-20250514',
  host,
  systemPrompt: 'You are a helpful assistant.',
})

const result = await agent.run('What files are in the current directory?')
console.log(result.text)
```

### Configuration Options

```typescript
import { AnthropicProvider } from '@mokei/anthropic-provider'

const provider = AnthropicProvider.fromConfig({
  // Required: Your Anthropic API key
  apiKey: 'sk-ant-...',
  
  // Optional: Base URL (default: https://api.anthropic.com/v1)
  baseURL: 'https://api.anthropic.com/v1',
  
  // Optional: Request timeout in ms (default: 60000)
  timeout: 60000,
  
  // Optional: Anthropic API version (default: 2023-06-01)
  anthropicVersion: '2023-06-01',
})
```

## Extended Thinking

Claude models with extended thinking capabilities will emit `reasoning-delta` events during streaming, which are captured in the `reasoning` field of aggregated messages.

## Limitations

- **No Embeddings**: Anthropic doesn't provide an embeddings API. Use OpenAI or another provider for embeddings.

## License

MIT
npm package: @mokei/context-client
Description: Mokei MCP client
Latest version: 0.6.0

# Mokei MCP client

## Installation

```sh
npm install @mokei/context-client
```

## Basic Usage

```typescript
import { ContextClient } from '@mokei/context-client'
import { NodeStreamsTransport } from '@enkaku/node-streams-transport'

const transport = new NodeStreamsTransport({ streams })
const client = new ContextClient({ transport })

await client.initialize()

// List available tools
const { tools } = await client.listTools()

// Call a tool (untyped)
const result = await client.callTool({
  name: 'tool_name',
  arguments: { key: 'value' }
})
```

## Type-Safe Usage

For the best developer experience, use type-safe clients by importing server types.

### Using Server Types

If your server exports types using `ExtractServerTypes` from `@mokei/context-server`:

```typescript
import type { FetchServerTypes } from '@mokei/mcp-fetch'
import { ContextClient } from '@mokei/context-client'

// Create a typed client
const client = new ContextClient<FetchServerTypes>({ transport })
await client.initialize()

// Now all tool calls are type-checked!
const result = await client.callTool({
  name: 'get_markdown',
  arguments: { url: 'https://example.com' }  // ✓ Fully typed
})

// TypeScript will error on invalid arguments:
// arguments: { invalid: 'field' }  // ✗ Compile error
```

### Custom Context Types

You can also define custom context types manually:

```typescript
import { ContextClient, type ContextTypes } from '@mokei/context-client'

type MyContextTypes = {
  Tools: {
    greet: { name: string }
    calculate: { x: number; y: number }
  }
  Prompts: {
    welcome: { userName: string }
  }
}

const client = new ContextClient<MyContextTypes>({ transport })
await client.initialize()

// Typed tool calls
await client.callTool({
  name: 'greet',
  arguments: { name: 'Alice' }
})

// Typed prompt calls
await client.getPrompt({
  name: 'welcome',
  arguments: { userName: 'Bob' }
})
```

### Benefits of Type Safety

- **Autocomplete**: IDE suggests available tool/prompt names and argument fields
- **Compile-time errors**: Catch typos and invalid arguments before runtime
- **Refactoring safety**: Changes to server schemas are caught at compile time
- **Documentation**: Types serve as inline documentation

## API Reference

### Client Methods

- `initialize()` - Initialize the client connection
- `listTools()` - List available tools from the server
- `callTool(params)` - Call a tool with arguments
- `listPrompts()` - List available prompts from the server
- `getPrompt(params)` - Get a prompt with arguments
- `listResources()` - List available resources
- `readResource(params)` - Read a resource by URI

### Type Parameters

- `ContextTypes` - Define tool and prompt argument types
- `UnknownContextTypes` - Default untyped context (all tools/prompts accept `Record<string, unknown>`)

## [Documentation](https://mokei.dev)
npm package: @mokei/context-server
Description: Mokei MCP server
Latest version: 0.6.0

# Mokei MCP server

## Installation

```sh
npm install @mokei/context-server
```

## Basic Usage

```typescript
import { createTool, serveProcess } from '@mokei/context-server'

serveProcess({
  name: 'my-server',
  version: '1.0.0',
  tools: {
    greet: createTool(
      'Greet a user by name',
      {
        type: 'object',
        properties: {
          name: { type: 'string' }
        },
        required: ['name']
      } as const,
      async (req) => {
        return {
          content: [{ type: 'text', text: `Hello, ${req.arguments.name}!` }]
        }
      }
    )
  }
})
```

## Type-Safe Client Integration

The `@mokei/context-server` package provides utilities to extract TypeScript types from your server configuration, enabling type-safe client usage.

### Extracting Types

Use `ExtractServerTypes` to derive types from your server configuration:

```typescript
import {
  createTool,
  type ExtractServerTypes,
  type ServerConfig,
  type ToolDefinitions
} from '@mokei/context-server'

const tools = {
  greet: createTool(
    'Greet a user by name',
    {
      type: 'object',
      properties: {
        name: { type: 'string', description: 'User name' }
      },
      required: ['name'],
      additionalProperties: false
    } as const,
    async (req) => {
      return {
        content: [{ type: 'text', text: `Hello, ${req.arguments.name}!` }]
      }
    }
  )
} satisfies ToolDefinitions

export const config = {
  name: 'my-server',
  version: '1.0.0',
  tools
} satisfies ServerConfig

// Export types for client usage
export type MyServerTypes = ExtractServerTypes<typeof config>
```

### Using Extracted Types in Clients

Import the exported types to get full type safety in your client:

```typescript
import type { MyServerTypes } from './my-server'
import { ContextClient } from '@mokei/context-client'

const client = new ContextClient<MyServerTypes>({ transport })
await client.initialize()

// TypeScript knows the exact shape of arguments!
const result = await client.callTool({
  name: 'greet',
  arguments: { name: 'Alice' }  // ✓ Type-checked
})

// This will error at compile time:
// arguments: { invalid: 'field' }  // ✗ Type error
```

### Available Type Utilities

- `ExtractServerTypes<T>` - Extract complete context types (Tools + Prompts)
- `ExtractToolTypes<T>` - Extract only tool argument types
- `ExtractPromptTypes<T>` - Extract only prompt argument types

## [Documentation](https://mokei.dev)
npm package: @mokeseven/gridsome-transformer-jsonapi
Description: A gridsome transformer for parsing JSON API spec'd API's
Author: Michael McGrath
Latest version: 0.0.8

![travis build](https://img.shields.io/travis/mokeseven7/gridsome-transformer-jsonapi.svg?) ![downloads](https://img.shields.io/npm/dw/@mokeseven/gridsome-transformer-jsonapi.svg?color=blue&logo=yoyo&logoColor=blue) ![coverage](https://coveralls.io/repos/github/mokeseven7/gridsome-transformer-jsonapi/badge.svg?branch=master)

# {JSON:API} Transformer 
This plugin is intended for use with the gridsome static site generation framework. Its purpose is to provide an easy to use GraphQL wrapper for existing JSON API Complient REST services. As such, this library will only work as a plugin to gridsome, and should not be used in any other context. 

# Quick Start
```
npm install @mokeseven/gridsome-transformer-jsonapi
```


### Credits: 
[NPM Boilerplate Used For Inspriation From Algolia](https://github.com/algolia/rollup-jest-boilerplate/blob/master/package.json)
npm package: @mokesh/custom-dropdown
Description: Responsive custom dropdown made in react
Latest version: 2.0.1

https://img.shields.io/github/issues/Mokesh-official/custom-dropdown
https://img.shields.io/github/forks/Mokesh-official/custom-dropdown
https://img.shields.io/github/stars/Mokesh-official/custom-dropdown
https://img.shields.io/github/license/Mokesh-official/custom-dropdown