open-index/open-npm huggingface dataset:
npm package: @karve.it/ngx-google-places-autocomplete
Description: This module is a wrapper for Google Places Autocomplete js library.
Latest version: 2.0.5

# ngx-google-places-autocomplete
This module is a wrapper for Google Places Autocomplete js library.

[![NPM](https://nodei.co/npm/ngx-google-places-autocomplete.png)](https://nodei.co/npm/ngx-google-places-autocomplete/)

# Installation
#### npm
```
npm install ngx-google-places-autocomplete
```
#### yarn
```
yarn add ngx-google-places-autocomplete
```
# Integration
1. Add google library in your index.html file : 
```
    <script src="https://maps.googleapis.com/maps/api/js?key=<Your API KEY>&libraries=places&language=en"></script>
```
2. Replace <You API KEY> with google places api key. Ref - https://developers.google.com/places/web-service/get-api-key

# Usage
1. Add a module into your application (as a rule app.module.ts)
```ts
import { GooglePlaceModule } from "ngx-google-places-autocomplete";

@NgModule({
    imports: [GooglePlaceModule, BrowserModule, FormsModule, ...],
        ....
        })
```
2. Add directive ngx-google-places-autocomplete to your input field (options is an optional parammeter)
```
<input ngx-google-places-autocomplete [options]='options' #placesRef="ngx-places" (onAddressChange)="handleAddressChange($event)"/>
```
3. Additionally you can reference directive in your component
```ts
    @ViewChild("placesRef") placesRef : GooglePlaceDirective;
    
        public handleAddressChange(address: Address) {
        // Do some stuff
    }
```

# Angular Universal
In order to use under angular universal please check that comment https://github.com/skynet2/ngx-google-places-autocomplete/issues/15#issuecomment-465371214

## Options
Refer to original google maps api - https://developers.google.com/maps/documentation/javascript/places-autocomplete
Options object - https://github.com/skynet2/ngx-google-places-autocomplete/blob/master/src/objects/options/options.ts
Google doc for Options : https://developers.google.com/maps/documentation/javascript/reference/places-widget#AutocompleteOptions
Example : 
```html  
[options]="{
    types: [],
    componentRestrictions: { country: 'UA' }
    }"
```

# GitHub
Please feel free to declare issues or contribute: https://github.com/skynet2/ngx-google-places-autocomplete
npm package: @karve/ui
Description: Modern UI component library with Tailwind CSS v4 and shadcn/ui
Author: Ramene Anthony
Latest version: 2.0.1

# @karve/ui

Modern UI component library built with **Tailwind CSS v4** and **shadcn/ui**.

## Features

- 🎨 **Tailwind CSS v4** - CSS-first architecture with `@theme` directive
- ⚡ **Fast** - 2-5x faster build performance vs Tailwind v3
- 🧩 **shadcn/ui Components** - Accessible, customizable React components
- 🎭 **Class Variance Authority** - Type-safe component variants
- 🌗 **Dark Mode** - Built-in dark mode support
- 📦 **TypeScript** - Full TypeScript support with type definitions

## Installation

```bash
pnpm add @karve/ui
# or
npm install @karve/ui
# or
yarn add @karve/ui
```

### Peer Dependencies

This package requires the following peer dependencies:

- `react` ^18
- `react-dom` ^18
- `tailwindcss` ^4.0.0

## Usage

### Import Components

```tsx
import { Button, Card, Input, Label } from '@karve/ui';

function App() {
  return (
    <Card>
      <Label htmlFor="email">Email</Label>
      <Input id="email" type="email" placeholder="you@example.com" />
      <Button>Submit</Button>
    </Card>
  );
}
```

### Import Styles

Import the base styles in your application:

```tsx
// In your main entry file (e.g., app.tsx or index.tsx)
import '@karve/ui/dist/styles.css';
```

Or use PostCSS to import in your CSS:

```css
/* styles.css */
@import '@karve/ui/dist/styles.css';
```

## Tailwind v4 Configuration

This package uses Tailwind CSS v4's CSS-first configuration. Your PostCSS config should include:

```js
// postcss.config.mjs
export default {
  plugins: {
    "@tailwindcss/postcss": {},
  },
};
```

## Available Components

- `Button` - Customizable button with variants
- `Badge` - Small status indicators
- `Card` - Container with header, content, and footer
- `Input` - Form input field
- `Label` - Form label
- `Textarea` - Multi-line text input
- `Select` - Dropdown selector
- `Drawer` - Slide-out panel (Vaul)
- `Tooltip` - Hover tooltips
- `BackgroundBoxes` - Animated background component

## Component Variants

Components use [Class Variance Authority](https://cva.style/) for type-safe variants:

```tsx
<Button variant="default" size="md">Default Button</Button>
<Button variant="destructive" size="lg">Delete</Button>
<Button variant="outline" size="sm">Cancel</Button>
```

## Styling

All components are built with Tailwind CSS v4 and support:

- Custom color schemes via CSS variables
- Dark mode with `.dark` class
- Responsive design with mobile-first approach
- Accessible ARIA attributes

## Development

```bash
# Install dependencies
pnpm install

# Build the package
pnpm build

# Watch mode for development
pnpm dev
```

## License

MIT © Ramene Anthony

## Links

- [Repository](https://github.com/ramene/mae.sh)
- [Tailwind CSS v4 Docs](https://tailwindcss.com)
- [shadcn/ui](https://ui.shadcn.com)
npm package: @karvin2c/feishu
Description: OpenClaw Feishu (Lark) channel plugin
Latest version: 2026.2.6

# @karvin2c/feishu

Feishu (Lark) channel plugin for OpenClaw. Connects via [Feishu Open Platform](https://open.feishu.cn/) event subscription and messaging APIs.

## Install (local checkout)

```bash
openclaw plugins install ./extensions/feishu
```

## Install (npm / pnpm)

```bash
pnpm add @karvin2c/feishu
# or
npm install @karvin2c/feishu
```

Then register the plugin in your OpenClaw config (e.g. `plugins.paths` or `plugins.packages`) or run onboarding and select Feishu.

Via CLI (if your config points at npm):

```bash
openclaw plugins install @karvin2c/feishu
```

## Config

```json5
{
  channels: {
    feishu: {
      enabled: true,
      appId: "cli_xxx",
      appSecret: "xxx",
      dm: { allowFrom: ["ou_xxx"] }
    }
  }
}
```

Or use env for the default account: `FEISHU_APP_ID`, `FEISHU_APP_SECRET`.

## Event subscription

Set the Feishu app request URL to `https://<your-gateway>/feishu/events`, add event **im.message.receive_v1**. See [Feishu channel setup](https://docs.openclaw.ai/channels/feishu) for full setup.

## Docs

- [Feishu channel setup](https://docs.openclaw.ai/channels/feishu)
- [OpenClaw plugins](https://docs.openclaw.ai/plugin)
npm package: @karyana-yandi/next-international
Description: Type-safe internationalization (i18n) for Next.js
Latest version: 1.3.0

<p align="center">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/QuiiBz/next-international/blob/main/assets/logo-white.png" />
    <source media="(prefers-color-scheme: light)" srcset="https://github.com/QuiiBz/next-international/blob/main/assets/logo-black.png" />
    <img alt="" height="100px" src="https://github.com/QuiiBz/next-international/blob/main/assets/logo-white.png" />
  </picture>
  <br />
  Type-safe internationalization (i18n) for Next.js
</p>

---

- [Features](#features)
- [Documentation](#documentation)
- [Sponsors](#sponsors)
- [License](#license)

## Features

- **100% Type-safe**: Locales in TS or JSON, type-safe `t()` & `scopedT()`, type-safe params, type-safe plurals, type-safe `changeLocale()`...
- **Small**: No dependencies, lazy-loaded
- **Simple**: No Webpack configuration, no CLI, no code generation, just pure TypeScript
- **Server and Client, Static Rendering**: Lazy-load server and client-side, support for Static Rendering
- **App or Pages Router**: With support for React Server Components

> **Note**: You can now build on top of the types used by next-international using [international-types](https://github.com/QuiiBz/next-international/tree/main/packages/international-types)!

Try it live on CodeSandbox:

[![Open with CodeSandbox](https://assets.codesandbox.io/github/button-edit-lime.svg)](https://codesandbox.io/p/sandbox/jovial-paper-skkprk?file=%2Fapp%2F%5Blocale%5D%2Fpage.tsx%3A1%2C1)

## Documentation

Check out the documentation at [https://next-international.vercel.app](https://next-international.vercel.app).

## Contributing

[See the contributing guide](./CONTRIBUTING.md).

## Sponsors

![Sponsors](https://github.com/QuiiBz/dotfiles/blob/main/sponsors.png?raw=true)

## License

[MIT](./LICENSE)
npm package: @karyum/express-session
Description: Simple session middleware for Express
Author: TJ Holowaychuk
Latest version: 1.18.1

If you're looking for the `express-session` package this is not it, but the repository link on the right will lead to it.


I made this package for a very specific use case where I don't want to use cookies to send the token, I wanted to use the auth header (Ive done this couple of years ago not sure why I needed this)
npm package: @karyum/fabricjs-react
Description: support fabricjs from react
Author: Alejandro Soto
Latest version: 1.3.9

# fabricjs-react fork

> This is a fork from [the following package](https://www.npmjs.com/package/fabricjs-react)

## To publish

Follow these steps

> Don't forget to change the version in the `package.json`

```bash
npm run build

npm login

npm publish
```

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

## Install

We'll need to install `fabric`, `react` and `react-dom` because are peer dependencies of this library if you haven't yet otherwise install only what you don't have:

```bash
npm install --save @karyum/fabricjs-react fabric react react-dom
```

## Usage

Take a look at sandbox: https://codesandbox.io/s/flamboyant-wind-ff3x8

```tsx
import React from 'react'

import { FabricJSCanvas, useFabricJSEditor } from 'fabricjs-react'

const App = () => {
  const { editor, onReady } = useFabricJSEditor()
  const onAddCircle = () => {
    editor?.addCircle()
  }
  const onAddRectangle = () => {
    editor?.addRectangle()
  }

  return (
    <div>
      <button onClick={onAddCircle}>Add circle</button>
      <button onClick={onAddRectangle}>Add Rectangle</button>
      <FabricJSCanvas className='sample-canvas' onReady={onReady} />
    </div>
  )
}

export default App
```

## Alternative use cases

### Add image ([#3](https://github.com/asotog/fabricjs-react/issues/3))

For this case, you have to reference the FabricJS dependency to first load the image:

```tsx
import { fabric } from 'fabric'; // this also installed on your project
import { useFabricJSEditor } from 'fabricjs-react';

const { selectedObjects, editor, onReady } = useFabricJSEditor();
useEffect(() => {
  fabric.Image.fromURL('my_image.png', function (oImg) {
    editor?.canvas.add(oImg);
  });
}, [fabric, editor])
...
```
npm package: @kas-tools/babel-plugin-react-visibility-attribute
Description: A Babel plugin that transforms `data-if` attributes into conditional rendering expressions at build time
Author: Kas Elvirov
Latest version: 0.2.0

# @kas-tools/babel-plugin-react-visibility-attribute

A Babel plugin that transforms `data-if` attributes into conditional rendering expressions (`cond && <Component />`) at build time

---

![JSX-first](https://img.shields.io/badge/JSX--first-%23e10098.svg)
![Zero-runtime](https://img.shields.io/badge/zero--runtime-%23green.svg)
![UX declarative](https://img.shields.io/badge/UX--attribute--driven-blueviolet)
![npm version](https://img.shields.io/npm/v/@kas-tools/babel-plugin-react-visibility-attribute)
![npm downloads](https://img.shields.io/npm/dm/@kas-tools/babel-plugin-react-visibility-attribute)
![Build](https://github.com/kas-elvirov/kas-tools/actions/workflows/ci.yml/badge.svg)

---

The main purpose is to "make markup clean again" ✊

## ✨ Features

You write

- `<SomeComponent data-if={condition} />`
  And it's transforms into (but you don't see it)
- `condition && <SomeComponent />`

## 🔧 Install

```bash
npm install @kas-tools/babel-plugin-react-visibility-attribute --save-dev
```

## 🧪 Usage

**babel.config.js**

```json
{
  "plugins": [
    [
      "@kas-tools/babel-plugin-react-visibility-attribute",
      {
        "attrName": "data-if",
        "enabled": true
      }
    ]
  ]
}
```

**vite.config.js**

```js
import { defineConfig } from 'vite';

import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [
    react({
      babel: {
        plugins: [
          [
            '@kas-tools/babel-plugin-react-visibility-attribute',
            {
              attrName: 'data-if',
              enabled: true,
            },
          ],
        ],
      },
    }),
  ],
});
```

## 🧾 Example

### Input in dev mode

```jsx
<SomeComponent data-if={isVisible} />
```

### In the browser

```jsx
// If isVisible === true

<SomeComponent />
```

```jsx
// If isVisible === false

null; // nothing
```

### Output in production build

```jsx
isVisible && <SomeComponent />;
```

## 🧪 Test

```bash
npm i -ddd
npm test
```

## 🖤 Inspiration

This package inspired by post [How to add custom attribute for conditional render?](https://stackoverflow.com/questions/79662332/how-to-add-custom-attribute-for-conditional-render) from [Mahdi](https://stackoverflow.com/users/2535843/mahdi) ([github](https://github.com/mahdix), [official website](https://mahdix.com/))

---

MIT License © 2025
npm package: @kas_roudra/fakeaws
Description: An aws simulator to run keep aws-syntax without using actual aws
Author: kas_roudra
Latest version: 0.0.2

# FakeAWS by KasRoudra

### It's dummy aws-sdk to maintain aws syntax without using actual aws. AWS is owned by Amazon and they have no affiliation with this project. 

#### Implemented classes 
```
S3Client, ECSClient, PutObjectCommand, RunTaskCommand
```
npm package: @kasaharu/ng-schematics
Description: Custom schematics
Author: kasaharu
Latest version: 0.1200.0

# ng-schematics

このリポジトリは Angular アプリケーション用の Custom Schematics です。

# Use

## Install

```bash
$ yarn add @kasaharu/ng-schematics -D
```

## Generate NgRx Store by this schematics

- Generate 2 files `src/app/features/store/hello.store.ts` and `src/app/features/store/hello.store.spec.ts`

```bash
$ yarn ng-schematics ngrx-store --name features/store/hello
```

- If multiple projects,

```bash
$ yarn ng-schematics ngrx-store --name features/store/hello --project other-app
```

# Development

## build and use

```bash
$ yarn build
$ yarn schematics .:ngrx-store --name features/store/hello --debug false
```

## test

```bash
$ yarn test
```
npm package: @kasaharu/ng-workbox
Description: ![](https://github.com/kasaharu/ng-workbox/workflows/Node%20CI/badge.svg)
Latest version: 0.1301.0

# ng-workbox

![](https://github.com/kasaharu/ng-workbox/workflows/Node%20CI/badge.svg)

## How to use

### Requirements

- [Angular CDK](https://material.angular.io/cdk/categories) - `$ yarn ng add @angular/cdk`

### Install

```
$ yarn add @kasaharu/ng-workbox
```
npm package: @kasarlabs/artpeace-mcp
Description: MCP server for collaborative pixel art creation on a shared canvas.
Author: kasarlabs
Latest version: 0.1.6

# Snak - ArtPeace Plugin

The ArtPeace Plugin provides tools for interacting with pixel art on the Starknet blockchain, allowing users to place pixels on a collaborative canvas.

## Features

This plugin adds the following tool:

- **place_pixel**: Places a pixel on the collaborative canvas, with optional parameters.

## Usage

The ArtPeace Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers this tool, making it available for use.

## Example

When asking the agent to perform ArtPeace-related tasks, it will use the place_pixel tool:

```
"Place a red pixel at position x:100, y:200"
"Draw a blue dot on the canvas at coordinates 150,300"
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/avnu-mcp
Description: MCP server for AVNU token swapping on Starknet
Author: kasarlabs
Latest version: 0.1.5

# Snak - AVNU Plugin

The AVNU Plugin provides tools for interacting with the AVNU decentralized exchange on the Starknet blockchain, enabling token swaps and route information.

## Features

This plugin adds the following tools:

- **avnu_swap_tokens**: Swap a specified amount of one token for another token.
- **avnu_get_route**: Get a specific routing path for a token swap.

### Token Identification

Both tools support identifying tokens by:

- **Symbol**: Use token symbols (e.g., `ETH`, `USDC`, `DAI`)
- **Address**: Use token contract addresses directly

You can mix and match - use a symbol for one token and an address for the other, or use addresses for both. For example:

- Use symbols for both: `{ sellTokenSymbol: "ETH", buyTokenSymbol: "USDC" }`
- Use addresses for both: `{ sellTokenAddress: "0x...", buyTokenAddress: "0x..." }`
- Mix them: `{ sellTokenSymbol: "ETH", buyTokenAddress: "0x..." }`

## Usage

The AVNU Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform AVNU-related tasks, it will use the appropriate tool from this plugin:

```
"Swap 0.1 ETH for USDC on AVNU"  // Uses avnu_swap_tokens
"Find the best route to swap ETH to DAI"  // Uses avnu_get_route
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/braavos-mcp
Description: MCP server for Braavos wallet account creation and deployment on Starknet
Author: kasarlabs
Latest version: 0.1.4

# Snak - Braavos Plugin

The Braavos Plugin provides tools for creating and deploying Braavos wallet accounts on the Starknet blockchain.

## Features

This plugin adds the following tools:

- **create_new_braavos_account**: Create a new Braavos account and return the privateKey, publicKey, and contractAddress.
- **deploy_existing_braavos_account**: Deploy an existing Braavos Account and return the privateKey, publicKey, and contractAddress.

## Usage

The Braavos Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Braavos-related tasks, it will use the appropriate tool from this plugin:

```
"Create a new Braavos wallet for me"  // Uses create_new_braavos_account
"Deploy my existing Braavos account"  // Uses deploy_existing_braavos_account
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/contract-mcp
Description: MCP server for Starknet contract operations including declaration and deployment.
Author: kasarlabs
Latest version: 0.1.5

# Snak - Contract Plugin

The Contract Plugin provides comprehensive tools for declaring, deploying, and managing Starknet smart contracts.

## Features

This plugin adds the following tools:

- **declare_contract**: Declare a Starknet contract using sierra and casm file paths.
- **deploy_contract**: Deploy a declared Starknet contract using sierra and casm file paths.
- **get_constructor_params**: Get constructor parameters from a contract sierra file.

## Usage

The Contract Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform contract-related tasks, it will use the appropriate tool from this plugin:

```
"Declare my contract using these files..."  // Uses declare_contract
"Deploy the contract at class hash 0x..."  // Uses deploy_contract
"What are the constructor parameters for this contract?"  // Uses get_constructor_params
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/ekubo-mcp
Description: MCP server for Ekubo protocol interactions on Starknet
Author: kasarlabs
Latest version: 0.1.5

# Snak - Ekubo MCP

The Ekubo MCP provides tools for interacting with Ekubo Protocol, the next-generation AMM (Automated Market Maker) on Starknet that revolutionizes DeFi with ultra-concentrated liquidity and singleton architecture.

## About Ekubo Protocol

Ekubo is Starknet's leading AMM, commanding 60% of the total AMM TVL and the majority of trading volume on the network. Built by former Uniswap Labs engineers, it features:

- **Singleton Architecture**: All pools consolidated into a single Cairo smart contract for 99% cheaper pool creation
- **Ultra-Concentrated Liquidity**: Up to 100x more capital efficient positions with precision down to 1/100th of a basis point
- **Extensions System**: Custom pool logic deployment without governance approval
- **Till Pattern**: Gas-optimized deferred token transfers

## Features

This MCP adds the following tools:

### Read Operations

- **get_pool_info**: Get comprehensive information about an Ekubo pool including current price, liquidity, and fee data.
- **get_token_price**: Get the price of a token via Ekubo pools by querying the pool price directly from the Core contract.
- **get_pool_liquidity**: Get the total liquidity available in an Ekubo pool at the current tick.
- **get_pool_fees_per_liquidity**: Get the cumulative fees per unit of liquidity for an Ekubo pool (both token0 and token1).

### Write Operations

- **swap**: Swap tokens on Ekubo DEX. Supports both exact input and exact output swaps with configurable slippage tolerance.
- **create_position**: Create a new liquidity position (NFT) in an Ekubo pool within a specified price range (concentrated liquidity).
- **add_liquidity**: Add liquidity to an existing Ekubo pool position without minting a new NFT.
- **withdraw_liquidity**: Withdraw liquidity from an Ekubo pool position. Can withdraw full position, partial position, or only collect fees.
- **transfer_position**: Transfer an Ekubo NFT position to another address.

## Usage

The Ekubo MCP is used by Claude Code and compatible MCP clients. Configure it in your MCP settings to enable Ekubo Protocol functionality.

## Example

When asking the agent to perform Ekubo-related tasks, it will use the appropriate tool from this MCP:

```
"Get info about the ETH/USDC pool on Ekubo"  // Uses get_pool_info
"What's the price of STRK on Ekubo?"  // Uses get_token_price
"How much liquidity is in the ETH/USDC pool?"  // Uses get_pool_liquidity
"Swap 0.1 ETH for USDC on Ekubo"  // Uses swap
"Create a liquidity position for ETH/USDC"  // Uses create_position
"Add liquidity to my existing position"  // Uses add_liquidity
"Withdraw liquidity from my position"  // Uses withdraw_liquidity
"Transfer my position NFT to another address"  // Uses transfer_position
```

## Development

To extend this MCP, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/erc20-mcp
Description: MCP server for comprehensive ERC20 token operations including transfers, allowances, and contract deployment.
Author: kasarlabs
Latest version: 0.1.5

# Snak - ERC20 Plugin

The ERC20 Plugin provides comprehensive tools for interacting with ERC20 tokens on the Starknet blockchain.

## Features

This plugin adds the following tools:

- **erc20_get_allowance**: Get the amount of tokens that a spender is allowed to spend on behalf of an owner.
- **erc20_get_my_given_allowance**: Get the amount of tokens that a spender is allowed to spend on your behalf.
- **erc20_get_allowance_given_to_me**: Get the amount of tokens that you are allowed to spend on behalf of an owner.
- **erc20_get_total_supply**: Get the total supply of a token.
- **erc20_transfer_from**: Transfer tokens from one address to another using an allowance.
- **erc20_get_balance**: Get the balance of an asset for a given wallet address.
- **erc20_get_own_balance**: Get the balance of an asset in your wallet.
- **erc20_approve**: Approve a spender to spend tokens on your behalf.
- **erc20_transfer**: Transfer ERC20 tokens to a specific address.
- **erc20_deploy_new_contract**: Create and deploy a new ERC20 contract.
- **erc20_get_symbol**: Get the symbol of an ERC20 token from its contract address.

## Usage

The ERC20 Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform ERC20-related tasks, it will use the appropriate tool from this plugin:

```
"Approve 50 USDC for address 0x1234..."  // Uses erc20_approve
"What's the total supply of DAI?"  // Uses erc20_get_total_supply
"Deploy a new token called MyToken"  // Uses erc20_deploy_new_contract
"What's the symbol of token at address 0x1234..."  // Uses erc20_get_symbol
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/erc721-mcp
Description: MCP server for ERC721 NFT management, including ownership, transfers, and approvals.
Author: kasarlabs
Latest version: 0.1.4

# Snak - ERC721 Plugin

The ERC721 Plugin provides comprehensive tools for interacting with ERC721 Non-Fungible Tokens (NFTs) on the Starknet blockchain.

## Features

This plugin adds the following tools:

- **erc721_owner_of**: Get the owner of a specific NFT.
- **erc721_get_balance**: Get the balance of NFTs for a given wallet address.
- **erc721_get_own_balance**: Get the balance of NFTs in your wallet.
- **erc721_is_approved_for_all**: Check if an operator is approved for all NFTs of a given owner.
- **erc721_get_approved**: Get the approved address for a specific NFT.
- **erc721_transfer_from**: Transfer an NFT from one address to another.
- **erc721_transfer**: Transfer an NFT to a specific address.
- **erc721_approve**: Approve an address to manage a specific NFT.
- **erc721_safe_transfer_from**: Safely transfer an NFT from one address to another with additional data.
- **erc721_set_approval_for_all**: Set or revoke approval for an operator to manage all NFTs of the caller.
- **deploy_erc721**: Create and deploy a new ERC721 contract.

## Usage

The ERC721 Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform NFT-related tasks, it will use the appropriate tool from this plugin:

```
"Who owns the NFT with ID 123 in collection 0x1234...?"  // Uses erc721_owner_of
"Transfer my NFT to 0x5678..."  // Uses erc721_transfer
"Deploy a new NFT collection"  // Uses deploy_erc721
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/fibrous-mcp
Description: MCP server for interacting with the Fibrous decentralized exchange, enabling single and batch token swaps.
Author: kasarlabs
Latest version: 0.1.5

# Snak - Fibrous Plugin

The Fibrous Plugin provides comprehensive tools for token swapping on Starknet using the Fibrous Router protocol, which finds the best routes across multiple DEXs.

## Features

This plugin adds the following tools:

- **fibrous_swap**: Swap a token for another token using the optimal route.
- **fibrous_batch_swap**: Swap multiple tokens for another token in a single transaction.
- **fibrous_get_route**: Get a specific route for swapping tokens with detailed path information.

## Usage

The Fibrous Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Fibrous-related tasks, it will use the appropriate tool from this plugin:

```
"Swap 100 USDC for ETH"  // Uses fibrous_swap
"What's the best route to swap DAI for STRK?"  // Uses fibrous_get_route
"Swap multiple tokens to USDC"  // Uses fibrous_batch_swap
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/mist-cash-mcp
Description: MCP server for interacting with the Mist Cash protocol on Starknet
Author: kasarlabs
Latest version: 0.1.1

# Mist Cash MCP Server

MCP server for interacting with the Mist Cash protocol on Starknet.

## Overview

This MCP server provides tools to interact with the Mist Cash protocol, enabling privacy-preserving transactions on Starknet.

## Installation

```bash
npm install @kasarlabs/mist-cash-mcp
```

## Usage

### Configuration

Create a `.env` file with the following variables:

```env
STARKNET_RPC_URL=your_rpc_url
ACCOUNT_ADDRESS=your_account_address
PRIVATE_KEY=your_private_key
# Add other Mist Cash specific configuration
```

### Running the Server

```bash
npm run build
npm start
```

## Available Tools

### `mist_cash_example`

Example tool for Mist Cash protocol interaction.

**Parameters:**

- Add your parameters here

**Returns:**

- Add return value description

## Development

### Build

```bash
npm run build
```

### Clean

```bash
npm run clean
```

### Clean All (including node_modules)

```bash
npm run clean:all
```

## Implementation Guide

1. Define your schemas in `src/schemas/index.ts`
2. Implement your tools in `src/tools/`
3. Register your tools in `src/index.ts`
4. Add any interfaces in `src/interfaces/`
5. Add helper functions in `src/lib/`

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
npm package: @kasarlabs/okx-mcp
Description: MCP server for OKX wallet account creation and deployment on Starknet
Author: kasarlabs
Latest version: 0.1.4

# Snak - OKX Plugin

The OKX Plugin provides tools for creating and deploying OKX wallet accounts on the Starknet blockchain.

## Features

This plugin adds the following tools:

- **create_new_okx_account**: Create a new OKX account and return the privateKey, publicKey, and contractAddress.
- **deploy_existing_okx_account**: Deploy an existing OKX Account and return the privateKey, publicKey, and contractAddress.

## Usage

The OKX Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform OKX-related tasks, it will use the appropriate tool from this plugin:

```
"Create a new OKX wallet for me"  // Uses create_new_okx_account
"Deploy my existing OKX account"  // Uses deploy_existing_okx_account
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/openzeppelin-mcp
Description: MCP server for creating and deploying OpenZeppelin account contracts on Starknet.
Author: kasarlabs
Latest version: 0.1.4

# Snak - OpenZeppelin Plugin

The OpenZeppelin Plugin provides tools for creating and deploying OpenZeppelin account contracts on the Starknet blockchain.

## Features

This plugin adds the following tools:

- **create_new_openzeppelin_account**: Create a new OpenZeppelin account and return the privateKey, publicKey, and contractAddress.
- **deploy_existing_openzeppelin_account**: Deploy an existing OpenZeppelin Account and return the privateKey, publicKey, and contractAddress.

## Usage

The OpenZeppelin Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform OpenZeppelin-related tasks, it will use the appropriate tool from this plugin:

```
"Create a new OpenZeppelin wallet for me"  // Uses create_new_openzeppelin_account
"Deploy my existing OpenZeppelin account"  // Uses deploy_existing_openzeppelin_account
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/opus-mcp
Description: MCP server for interacting with the Opus lending protocol, enabling creation and management of Troves for borrowing.
Author: kasarlabs
Latest version: 0.1.4

# Snak - Opus Plugin

The Opus Plugin provides comprehensive tools for interacting with the Opus protocol on Starknet, a decentralized borrowing platform where users can create and manage Troves (collateralized debt positions).

## Features

This plugin adds the following tools:

- **open_trove**: Open a new Trove on Opus with collateral and borrow CASH.
- **get_user_troves**: Get trove IDs for a specific address on Opus.
- **get_trove_health**: Get the health metrics of a specific trove.
- **get_borrow_fee**: Get the current borrow fee for Opus.
- **deposit_trove**: Deposit additional collateral to an existing Trove.
- **withdraw_trove**: Withdraw collateral from a Trove on Opus.
- **borrow_trove**: Borrow additional CASH from an existing Trove.
- **repay_trove**: Repay CASH debt for a Trove on Opus.

## Usage

The Opus Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Opus-related tasks, it will use the appropriate tool from this plugin:

```
"Open a trove with 1 ETH collateral and borrow 1000 CASH"  // Uses open_trove
"What troves do I have on Opus?"  // Uses get_user_troves
"Check the health of my trove"  // Uses get_trove_health
"Deposit more collateral to my trove"  // Uses deposit_trove
"Repay 500 CASH on my trove"  // Uses repay_trove
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/scarb-mcp
Description: MCP server for Scarb Cairo compilation and program execution operations.
Author: kasarlabs
Latest version: 0.1.4

# Snak - Scarb Plugin

The Scarb Plugin provides comprehensive tools for managing Scarb projects, the build toolchain for Cairo and Starknet smart contracts.

## Features

This plugin adds the following tools:

- **install_scarb**: Install Scarb Cairo toolchain with optional version specification.
- **init_project**: Initialize a new Scarb project with specified name and options.
- **build_project**: Build a Scarb project with specified build options.
- **execute_program**: Execute a Cairo program with optional function and arguments.
- **prove_program**: Generate a proof for a Cairo program execution using Stone prover.
- **verify_program**: Verify a proof generated for a Cairo program.

## Usage

The Scarb Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Scarb-related tasks, it will use the appropriate tool from this plugin:

```
"Install Scarb version 2.5.0"  // Uses install_scarb
"Initialize a new Cairo project called my_project"  // Uses init_project
"Build my Scarb project"  // Uses build_project
"Execute the main function in my Cairo program"  // Uses execute_program
"Generate a proof for my Cairo program"  // Uses prove_program
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/starknet-rpc-mcp
Description: MCP server for direct blockchain interaction via RPC methods, providing access to on-chain data and state.
Author: kasarlabs
Latest version: 0.1.6

# Snak - RPC Plugin

The RPC Plugin provides tools for interacting directly with the Starknet blockchain via RPC (Remote Procedure Call) methods, enabling access to blockchain data and state.

## Features

This plugin adds the following RPC tools:

- **get_chain_id**: Retrieve the unique identifier (chain ID) of the Starknet network.
- **get_syncing_status**: Retrieve the syncing status of the Starknet node.
- **get_class_hash**: Retrieve the unique class hash for a contract at a specific address.
- **get_spec_version**: Get the current spec version from the Starknet RPC provider.
- **get_block_with_tx_hashes**: Retrieve block details including transaction hashes.
- **get_block_with_receipts**: Fetch block details with transaction receipts.
- **get_transaction_status**: Fetch transaction status by hash.
- **get_block_number**: Get the current block number from the Starknet network.
- **get_block_transaction_count**: Get the number of transactions in a specific block.
- **get_storage_at**: Get the storage value at a specific slot for a contract.
- **get_class**: Retrieve the complete class definition of a contract.
- **get_class_at**: Fetch the class definition of a contract at a specific address.

## Usage

The RPC Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform RPC-related tasks, it will use the appropriate tool from this plugin:

```
"What's the current block number?"  // Uses get_block_number
"Show me the status of transaction 0x1234..."  // Uses get_transaction_status
"What's the chain ID of the current network?"  // Uses get_chain_id
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/transaction-mcp
Description: MCP server for simulating various types of transactions without execution.
Author: kasarlabs
Latest version: 0.1.6

# Snak - Transaction Plugin

The Transaction Plugin provides tools for simulating various types of transactions on the Starknet blockchain without actually executing them.

## Features

This plugin adds the following simulation tools:

- **simulate_transaction**: Simulate an invoke transaction without executing it.
- **simulate_deploy_transaction**: Simulate a deploy transaction.
- **simulate_declare_transaction**: Simulate a declare transaction.
- **simulate_deploy_account_transaction**: Simulate a deploy account transaction.

## Usage

The Transaction Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform transaction-related tasks, it will use the appropriate tool from this plugin:

```
"What would happen if I called this contract function?"  // Uses simulate_transaction
"Show me the result of deploying this contract without actually deploying it"  // Uses simulate_deploy_transaction
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/tools/index.ts`.
npm package: @kasarlabs/troves-mcp
Description: MCP server for Troves strategies API on Starknet
Author: kasarlabs
Latest version: 0.1.5

# Snak - Troves Plugin

The Troves Plugin provides tools for fetching strategies from Troves API on Starknet.

## Features

This plugin adds the following tools:

- **troves_get_strategies**: Get all strategies from Troves API (https://app.troves.fi/api/strategies).

## Usage

The Troves Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Troves-related tasks, it will use the appropriate tool from this plugin:

```
"Get Troves strategies"  // Uses troves_get_strategies
"Show me available strategies on Troves"  // Uses troves_get_strategies
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/unruggable-mcp
Description: MCP server for creating and analyzing memecoins with focus on safer token launches and liquidity locking.
Author: kasarlabs
Latest version: 0.1.4

# Snak - Unruggable Plugin

The Unruggable Plugin provides comprehensive tools for creating and managing memecoins on Starknet using the Unruggable protocol, which ensures fair launches with locked liquidity.

## Features

This plugin adds the following tools:

- **is_memecoin**: Check if a given address is a memecoin created by the Unruggable Factory.
- **get_locked_liquidity**: Get locked liquidity information for a specific token.
- **create_memecoin**: Create a new memecoin using the Unruggable Factory with specified parameters.
- **launch_on_ekubo**: Launch a memecoin on Ekubo DEX with concentrated liquidity.

## Usage

The Unruggable Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Unruggable-related tasks, it will use the appropriate tool from this plugin:

```
"Create a memecoin called PEPE with 1 million supply"  // Uses create_memecoin
"Is this token an Unruggable memecoin?"  // Uses is_memecoin
"Check the locked liquidity for this token"  // Uses get_locked_liquidity
"Launch my memecoin on Ekubo"  // Uses launch_on_ekubo
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kasarlabs/vesu-mcp
Description: MCP server for interacting with the Vesu protocol, enabling deposit and withdrawal operations for earning positions.
Author: kasarlabs
Latest version: 0.1.5

# Snak - Vesu Plugin

The Vesu Plugin provides comprehensive tools for interacting with the Vesu protocol on Starknet, a lending and borrowing platform where users can deposit tokens to earn yield.

## Features

This plugin adds the following tools:

- **vesu_deposit_earn**: Deposit tokens to earn yield on Vesu protocol.
- **vesu_withdraw_earn**: Withdraw tokens from an earning position on Vesu protocol.

## Usage

The Vesu Plugin is used internally by the Starknet Agent and doesn't need to be called directly. When the agent is initialized, it automatically registers these tools, making them available for use.

## Example

When asking the agent to perform Vesu-related tasks, it will use the appropriate tool from this plugin:

```
"Deposit 100 USDC to earn on Vesu"  // Uses vesu_deposit_earn
"Withdraw my USDC from Vesu"  // Uses vesu_withdraw_earn
"Earn yield on my ETH using Vesu"  // Uses vesu_deposit_earn
```

## Development

To extend this plugin, add new tools in the `src/tools` directory and register them in the `registerTools` function in `src/index.ts`.
npm package: @kash_maxing/n8n-nodes-html-to-pdf
Description: n8n node for converting HTML to PDF using wkhtmltopdf
Author: diino
Latest version: 1.0.2

# HTML to PDF n8n Node

A custom n8n node for converting HTML content to PDF using wkhtmltopdf.

## Features

- Convert HTML content to PDF
- Convert HTML from URL to PDF
- Multiple output formats (Base64, Binary, File Path)
- Configurable page size and orientation
- Customizable margins
- JavaScript execution support
- Custom wkhtmltopdf options

## Prerequisites

This node requires wkhtmltopdf to be installed on your system. The node will automatically detect the correct path based on your operating system:

- **Windows**: `C:\Program Files\wkhtmltopdf\bin\wkhtmltopdf.exe`
- **Linux**: `/usr/bin/wkhtmltopdf`
- **macOS**: `/usr/local/bin/wkhtmltopdf`

### Windows
Download and install from: https://wkhtmltopdf.org/downloads.html

### macOS
```bash
brew install wkhtmltopdf
```

### Linux (Ubuntu/Debian)
```bash
sudo apt-get install wkhtmltopdf
```

### Linux (CentOS/RHEL/Fedora)
```bash
sudo yum install wkhtmltopdf
# or for newer versions:
sudo dnf install wkhtmltopdf
```

## Installation

1. Clone this repository
2. Install dependencies:
   ```bash
   npm install
   ```
3. Build the node:
   ```bash
   npm run build
   ```
4. Install in your n8n instance

## Usage

1. Add the "HTML to PDF" node to your workflow
2. Configure the input (HTML content or URL)
3. Set your preferred output format and options
4. Execute the workflow

## Configuration Options

- **HTML Content**: Direct HTML content to convert
- **HTML URL**: URL of a webpage to convert
- **Output Format**: Choose between Base64, Binary, or File Path
- **Page Size**: A4, A3, A5, Letter, Legal
- **Orientation**: Portrait or Landscape
- **Margins**: Top, Right, Bottom, Left margins
- **Enable JavaScript**: Allow JavaScript execution
- **Custom Options**: Additional wkhtmltopdf command-line options

## License

MIT
npm package: @kashcode/reduxish
Description: A tiny, fully-typed Redux-inspired state management library with store enhancement/plugin support for functionality such as thunking, logging, etc with full type inference on the enhanced store. Complies with flux architecture and fully compatible with re
Author: Kasope
Latest version: 0.8.0

# 🧃 Reduxish

A tiny, fully-typed Redux-inspired state management library with **store enhancement/plugin support for functionality such as thunking, logging, etc with full type inference on the enhanced store.** Complies with flux architecture and fully compatible with react-redux bindings.

---

## ✨ Features

### 🏪 Store Creation

Create a store with a **strongly‑typed state**, a **typed dispatch**, and a **simple subscription model**.

#### 🧩 Combine Reducers
Split your state into logical slices and merge them into a single root reducer.
- Store root state shape is automatically inferred from slices


---

### 🧠 Middleware Support

Intercept actions before they hit your reducers.

Perfect for:

- logging
- thunking/async flows
- side‑effects
- analytics

Middlewares are:

- composable
- fully typed

Use ```applyMiddleware``` utility to compose middlewares. This utility also infers the dispatch extensions applied by the middleware via ```InferDispatchExtensionsFromMiddlewareArray``` recursive helper type (caveat: middlewares should be defined as a tuple for inference to work)

##### Create store example with sotre enhancment/middelware support:
```
const middlewares = [resolveMiddleware, loggerMiddleware] as const;
const store = createStore(
  todoApp,
  {
    todos: []
  },
  applyMiddleware(middlewares),
);
```

---

### ⚛️ Using with React?

Continue using your usual react-redux hook bindings, no changes required!

- useDispatch, useSelector all work out of the box
- use typed versions of hooks by using our inferred types with react-redux "withTypes" utility
  - i.e
  ```
    type AppDispatch = typeof store.dispatch
    type RootState = ReturnType<typeof store.getState>
    export const useAppDispatch = useDispatch.withTypes<AppDispatch>()
    export const useAppSelector = useSelector.withTypes<RootState>()
  ```
---

## 📦 Installation

```bash
npm install @kashcode/reduxish
```
---

#### 📦 Note: this is a hobby project (not for production use). It is primarily to illustrate the simplicity of building a "redux" implementation from scratch