open-index/open-npm huggingface dataset:
npm package: @kimothokamau/btckes
Description: A realtime BTCKES price API
Latest version: 1.0.1

<h1 align="center">Welcome to @kimothokamau/btckes 👋</h1>
<p>
  <img alt="Version" src="https://img.shields.io/badge/version-1.0.0-blue.svg?cacheSeconds=2592000" />
  <a href="#" target="_blank">
    <img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" />
  </a>
</p>

> Real-time BTCKES price API



## Install

First ensure you have node and npm already installed. Confirm by running:
```sh
node -v
```
and

```sh
npm -v
```

Navigate to your project directory; where there is package.json

```sh
npm install btckes --save
```
npm package: @kimothokamau/btckesrate
Description: Real-time BTCKES price API endpoint
Latest version: 2.0.0

# @kimothokamau/legendary-waffle

[![npm (scoped)](https://img.shields.io/npm/v/@bamblehorse/tiny.svg)](https://www.npmjs.com/package/@bamblehorse/tiny)
[![npm bundle size (minified)](https://img.shields.io/bundlephobia/min/@bamblehorse/tiny.svg)](https://www.npmjs.com/package/@bamblehorse/tiny)

Removes all spaces from a string.

## Install

```
$ npm install @bamblehorse/tiny
```

## Usage

```js
const tiny = require("@bamblehorse/tiny");

tiny("So much space!");
//=> "Somuchspace!"

tiny(1337);
//=> Uncaught TypeError: Tiny wants a string!
//    at tiny (<anonymous>:2:41)
//    at <anonymous>:1:1
```
<!-- 
![Custom badge](https://img.shields.io/endpoint?style=flat-square&url=https%3A%2F%2Fgithub.com%2Fkimothokamau%2Flegendary-waffle)


<img alt="Custom badge" src="https://img.shields.io/endpoint?style=flat-square&url=https%3A%2F%2Fgithub.com%2Fkimothokamau%2Flegendary-waffle">
npm package: @kimpa0107/date2str
Description: Convert Data to formatted String
Author: Jasper Kim
Latest version: 0.0.2

## Convert Date to string


### Usages

```javascript
const { dateToString } = require('@kimpa0107/date2str');

const date = new Date();
const res = dateToString(date, 'YYYY-MM-DD HH:mm:ss');

console.log(res);
```

### Format

year: `YYYY`
month: `MM`
day: `DD`
hour: `HH`
minute: `mm`
second: `ss`
npm package: @kimpaow/sanity-plugin-mux-video-input
Description: An input component that integrates Sanity Studio with MUX.com video encoding/hosting service.
Author: Kim Björkman
Latest version: 0.0.0

# Mux Video Input Sanity Plugin

This is an unofficial update to the Mux Video Input Plugin that was originally created by the Sanity team. It resolves some bugs and uses the new Sanity UI components.

This is a plugin which let you use [MUX.com](https://www.mux.com) video assets in your Sanity studio.

The Mux plugin for Sanity gives you a way to upload and preview videos easily.

[Read our blog post](https://www.sanity.io/blog/first-class-responsive-video-support-with-the-new-mux-plugin) about this plugin.

Not familiar with Sanity? [Visit www.sanity.io](https://www.sanity.io/)

## Quick start

- While in your project folder, run `sanity install mux-video-input`.
  Read more about [using plugins in Sanity here](https://www.sanity.io/docs/plugins).

* Make a schema type that uses the plugin's type `mux.video`, for example:

  ```js
  {
    title: "Video blog post",
    name: "videoBlogPost",
    type: "document",
    fields: [
      { title: "Title", name: "title", type: "string" },
      {
        title: "Video file",
        name: "video",
        type: "mux.video"
      }
    ]
  }
  ```

  Read more about [schemas in Sanity here](https://www.sanity.io/docs/the-schema).

- Get an API Access Token and enter it into the setup screen
  First time you use the plugin you will be asked to enter your MUX credentials.

  The Mux Video API uses an Access Token and Secret Key for authentication.

  If you haven't already, generate a new Access Token in the Access Token settings of your Mux account dashboard, and make sure it got permission to both read and write _video_ and read _data_.

  The token is stored in the dataset as a document of the type `mux.apiKey` with the id `secrets.mux`.
  Having the ID be non-root ensures that only editors are able to see it.

  The MUX plugin will find it’s access tokens by fetching this document.

# Playing videos in the frontend

We have made an own player which supports poster images for the videos as set with this plugin, see [`sanity-mux-player`](https://github.com/sanity-io/sanity-mux-player)

You could use any player which supports HLS, just point the video source to:

`https://stream.mux.com/${assetDocument.playbackId}.m3u8`
npm package: @kimseungwon/style
Description: A package for styling components in a project.
Author: kimseungwon
Latest version: 0.0.22


# @kimseungwon/style
NPM 패키지 Repository

## Features
- 🎨 Easy-to-use styling Component
- 🔧 Full TypeScript support

### Installation
```bash
npm install @kimseungwon/style
```

### Version
`0.0.3`

### Component

- TopScrollAnimation
- Go Scroll Top Button
npm package: @kimskovhusandersen/ui-library
Description: An interface library crafted for React, integrating Tailwind CSS, Vite, TypeScript, and Radix UI and Shadcn UI components.
Author: Kim Skovhus Andersen
Latest version: 1.0.27

# @kimskovhusandersen/ui-library

**@kimskovhusandersen/ui-library** is a React interface library that seamlessly integrates Tailwind CSS, Vite, TypeScript, and Radix UI and Shadcn UI components.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)

## Installation

You can easily install **@kimskovhusandersen/ui-library** using your preferred package manager:

```bash
# Using npm
npm install @kimskovhusandersen/ui-library

# Using yarn
yarn add @kimskovhusandersen/ui-library
```

## Usage

Integrate @kimskovhusandersen/ui-library into your React application to take advantage of its Radix UI and Shadcn UI components. Here's an example of how to use the components in your React code:

```typescript

import React from 'react';
import { Avatar, Button } from '@kimskovhusandersen/ui-library';

function App() {
  return (
    <>
      <Avatar
        src="https://images.unsplash.com/photo-1492633423870-43d1cd2775eb?w=128&h=128&dpr=2&q=80"
        alt="Colm Tuite"
      >
        FM
      </Avatar>
      <Button variant="default" size="md">Label</Button>
    </>
  );
  );
}

export default App;
```

## Contributing

We welcome contributions to @kimskovhusandersen/ui-library! If you'd like to contribute, please follow these guidelines:

Fork the repository on GitHub.
Clone your forked repository and set it up as described in the Installation section.
Create a new branch for your feature or bug fix.
Make your changes and test them.
Submit a pull request to the main repository.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgements

We would like to express our gratitude to the creators of Radix UI and Shadcn UI for their outstanding work and open-source contributions. This project would not be possible without their support and fantastic components.
npm package: @kimtaeyoon83/mcp-server-youtube-transcript
Description: This is an MCP server that allows you to directly download transcripts of YouTube videos.
Author: Freddie
Latest version: 0.1.1

# YouTube Transcript Server

A Model Context Protocol server that enables retrieval of transcripts from YouTube videos. This server provides direct access to video captions and subtitles through a simple interface.

## Components

### Tools

- **get_transcript**
  - Extract transcripts from YouTube videos
  - Inputs:
    - `url` (string, required): YouTube video URL or video ID
    - `lang` (string, optional, default: "en"): Language code for transcript (e.g., 'ko', 'en')

## Key Features

- Support for multiple video URL formats
- Language-specific transcript retrieval
- Detailed metadata in responses

## Configuration

To use with Claude Desktop, add this server configuration:

```json
{
  "mcpServers": {
    "youtube-transcript": {
      "command": "npx",
      "args": ["-y", "@kimtaeyoon83/mcp-server-youtube-transcript"]
    }
  }
}
```

## Development

### Prerequisites

- Node.js 18 or higher
- npm or yarn

### Setup

Install dependencies:
```bash
npm install
```

Build the server:
```bash
npm run build
```

For development with auto-rebuild:
```bash
npm run watch
```

### Testing

```bash
npm test
```

### Debugging

Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the MCP Inspector for development:

```bash
npm run inspector
```

## Error Handling

The server implements robust error handling for common scenarios:
- Invalid video URLs or IDs
- Unavailable transcripts
- Language availability issues
- Network errors

## Usage Examples

1. Get transcript by video URL:
```typescript
await server.callTool("get_transcript", {
  url: "https://www.youtube.com/watch?v=VIDEO_ID",
  lang: "en"
});
```

2. Get transcript by video ID:
```typescript
await server.callTool("get_transcript", {
  url: "VIDEO_ID",
  lang: "ko"
});
```

3. How to Extract YouTube Subtitles in Claude Desktop App
```
chat: https://youtu.be/ODaHJzOyVCQ?si=aXkJgso96Deri0aB Extract subtitles
```

## Security Considerations

The server:
- Validates all input parameters
- Handles YouTube API errors gracefully
- Implements timeouts for transcript retrieval
- Provides detailed error messages for troubleshooting

## License

This MCP server is licensed under the MIT License. See the LICENSE file for details.
npm package: @kimusoft/discord-menu
Description: > Use Discord components without unnecessarily long codes. * Typescript * discord.js v14.17.3
Latest version: 2.1.0

## Discord Menu Library
> Use Discord components without unnecessarily long codes.
* Typescript
* discord.js v14.17.3

## Features
* Sample discord button component menus
* Simple discord select menu component menus
* Simple pagination component

## Examples
### Yes or No Button
```typescript
async function yesNoTest(i: ChatInputCommandInteraction) {
  // Send a message with buttons with Yes and No.
  const resI = await i.sendMenu({
    content: "Do you know Gangnam Style?",
    menu: new YesNoMenu(),
  })

  // Returns void if the response time limit has been exceeded.
  if (!resI) return i.editReply({ content: "Timeout!" })

  // You can check which button the user pressed through 'resI.customId'
  switch (resI.customId) {
    case CustomId.YesButton:
      return i.editReply({ content: "You choose Yes!" })
    case CustomId.NoButton:
      return i.editReply({ content: "You choose No!" })
  }
}
```
npm package: @kimuson/hono-rpc-msw-adapter
Description: A lightweight library for creating type-safe MSW mock handlers for endpoints accessible via Hono RPC.
Latest version: 0.0.2

# hono-rpc-msw-adapter

A lightweight library for creating type-safe MSW mock handlers for endpoints accessible via Hono RPC.

While Hono's official RPC feature enables type-safe resource access from the frontend, it doesn't provide a way to register MSW mocks in a type-safe manner. This library fills that gap.

## Installation

```bash
pnpm add @kimuson/hono-rpc-msw-adapter
```

## Usage

### 1. Define your Hono API with schema

```typescript
import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import z from 'zod';

const app = new Hono()
  .get('/posts', zValidator('query', z.object({ limit: z.string().optional() })), (c) => {
    return c.json({ posts: ['Post 1', 'Post 2'] }, 200);
  })

export type AppType = typeof app;
```

### 2. Create a Hono Client and register API type for msw adapter

```typescript
// path/to/api/client.ts
import { hc } from 'hono/client';
import { setConfig } from '@kimuson/hono-rpc-msw-adapter';
import type { AppType } from '/path/to/api';

const baseUrl = 'http://localhost:3000'

// for msw adapter
setConfig({ baseUrl });
declare module '@kimuson/hono-rpc-msw-adapter/register' {
  interface Register {
    routeType: AppType;
  }
}

// hono client
export const client = hc<AppType>(baseUrl);
```

The `declare module` statement registers your API type with `@kimuson/hono-rpc-msw-adapter`. This enables declaration merging of the API type, allowing the library to provide type-safe handler generation based on your API schema.

### 3. Create MSW handlers

```typescript
import { createHandler } from '@kimuson/hono-rpc-msw-adapter';
import { setupServer } from 'msw/node';

export const postsHandler = createHandler(
  '/posts',
  '$get',
  async ({ input }) => {
    return {
      status: 200,
      output: { posts: ['Post 1', 'Post 2'] },
    };
  },
);
```

The `createHandler` function is fully type-safe and only accepts endpoints that actually exist in your API (e.g., `/posts` in the example above).

It also validates HTTP methods, ensuring only defined methods are accepted. The handler implementation receives typed `input` for building your mock, and the return value must satisfy the response schema type.

The resulting `postsHandler` is a ready-to-use MSW handler that can be registered with `server.use()` in a properly configured MSW setup.

For MSW configuration details, please refer to the MSW documentation.

## API

### Handler Callback

The handler callback receives the following context:

- `input`: Type-safe query params, path params, and body data
- `requestId`: Request ID
- `cookies`: Request cookies
- `request`: Request object

### setConfig

Call the `setConfig` function to configure global settings.

Available options:

- `baseUrl`: The base URL for requests. This should match the URL configured for your Hono client.

## License

MIT
npm package: @kimyu0218/custom-http
Description: ![npm](https://img.shields.io/npm/v/@kimyu0218/custom-http) ![npm](https://img.shields.io/npm/dt/@kimyu0218/custom-http)
Author: kimyu0218
Latest version: 0.0.17

## Custom Http

![npm](https://img.shields.io/npm/v/@kimyu0218/custom-http) ![npm](https://img.shields.io/npm/dt/@kimyu0218/custom-http)

`custom-http` is **a lightweight package that imitates the core functionality of the http module**. It provides some essential classes and constants, making it easy to create HTTP servers and clients in your application.

### Installation ⬇️

```bash
npm i @kimyu0218/custom-http
```

### Classes 💫

#### HttpRequest

The `HttpRequest` class represents the request made by the client. It provides various methods to access information about the request.

```ts
import { HttpRequest } from '@kimyu0218/custom-http';
...
const req: HttpRequest = new HttpRequest(data);
const path: string = req.getPath();
const method: string = req.getMethod();
```

#### HttpResponse

The `HttpResponse` class represents the response that the server sends back to the client. It provides methods to set response headers and body.

```ts
import { HttpResponse } from '@kimyu0218/custom-http';
...
const res: HttpResponse = new HttpResponse(socket);
res.throwError(404).send();
```

### Constants 💫

#### METHODS

The `METHODS` is an object containing HTTP methods.

```ts
import { METHODS } from '@kimyu0218/custom-http';

console.log(METHODS.GET); // GET
```

#### STATUS_CODES

The `STATUS_CODES` is an object containing HTTP status codes and their respective messages.

```ts
import { STATUS_CODES } from '@kimyu0218/custom-http';

console.log(STATUS_CODES[200]); // OK
```

#### CONTENT_TYPE

The `CONTENT_TYPE` is an object representing different content types. Each content type corresponds to a specific file extension.

```ts
import { CONTENT_TYPE } from '@kimyu0218/custom-http';

console.log(CONTENT_TYPE.HTML); // text/html
```

### Ongoing Development 🏃

It's important to note that this project is **still in development**. If you find any issues or have suggestions for improvements, feel free to open an issue.
npm package: @kin-lang/cli
Description: CLI utility for Kin Programming Language
Author: MURANGWA Pacifique
Latest version: 0.4.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

<p align="center">
  <a href="https://github.com/pacifiquem" target="blank"><img src="https://github.com/kin-lang/kin/blob/main/kin-logo.svg" width="120" alt="Kin Logo" /></a>
</p>

<p align="center">Write computer programs in Kinyarwanda! </p>

**Kin** is a straightforward programming language created with the purpose of aiding Kinyarwanda speakers in easily learning programming.

> This is CLI package for Kin Programming Language

## Installation

```shell
npm i -g @kin-lang/cli
```

## Usage

```shell
kin <command> <arguments>
```

## License

Kin's CLI is under MIT license.