open-index/open-npm huggingface dataset:
npm package: @hovoh/ethers-multicall
Description: Make multiple Ethereum network requests in a single HTTP query. ethcall for ethers v5.
Author: Cavan Flynn
Latest version: 1.0.0

# ethers-multicall

Make multiple Ethereum network requests in a single HTTP query. [ethcall](https://github.com/Destiner/ethcall) for ethers v5.

## API

* `Contract(address, abi)`: Create contract instance; calling `contract.callFuncName` will yield a `call` object
* `all(calls)`: Execute all calls in a single request
* `calls`: List of helper call methods
* `getEthBalance(address)`: Returns account ether balance

## Example

```ts
import { Contract, Provider } from 'ethers-multicall';
import { ethers } from 'ethers';

import erc20Abi from './abi/erc20.json';

const infuraKey = 'INSERT_YOUR_KEY_HERE';
const provider = new ethers.providers.InfuraProvider('mainnet', infuraKey);

const daiAddress = '0x6b175474e89094c44da98b954eedeac495271d0f';

async function call() {
  const ethcallProvider = new Provider(provider);

  await ethcallProvider.init(); // Only required when `chainId` is not provided in the `Provider` constructor

  const daiContract = new Contract(daiAddress, erc20Abi);

  const uniswapDaiPool = '0x2a1530c4c41db0b0b2bb646cb5eb1a67b7158667';

  const ethBalanceCall = ethcallProvider.getEthBalance(uniswapDaiPool);
  const daiBalanceCall = daiContract.balanceOf(uniswapDaiPool);

  const [ethBalance, daiBalance] = await ethcallProvider.all([ethBalanceCall, daiBalanceCall]);

  console.log('ETH Balance:', ethBalance.toString());
  console.log('DAI Balance:', daiBalance.toString());
}

call();
```
npm package: @hovoh/evmcontractsregistry
Description: Bundle all your bindings in an easy to use package that let's you abstract contract initialization and addresses
Author: HOVOH
Latest version: 0.3.9

# EVM Contracts Registry

Bundle all your bindings in an easy to use package that let's you abstract contract initialization and addresses

## How to use a library built with EVM Contracts Registry

### Providers Registry

The providers registry is an object containing all your rpc urls. You can instantiate your own or
use the one provided with the library with public RPCs:

`import { providers } from '@hovoh/evmcontractsregistry';`

You can add networks with the addNetwork function to the default provider.
If you want to use write function, you can specify your private key using setPrivateKey function.

### Contracts Registry

The Contracts Registry are mappings the addresses with a function to instanciate 
the EthersJs Contract object. 

Named bindings are contracts available on all networks.

In this case we use factories from Typechain generated using [typechain for ethers with multicall](https://github.com/HOVOH/TypeChain/tree/master/packages/target-ethers-multicall)

```typescript
import {
  contract,
  bindings
} from "@hovoh/evmcontractsregistry";

const deployedAtBlock = 999999;
const ethereumMainnet = {
    myErc20Token: contract("0xYourContractAddress", ERC20__factory.connect, ERC20__factory.multicall, deployedAtBlock),
}

const optimismMainnet = {
    myErc20Token: contract("0xYourContractAddress", ERC20__factory.connect, ERC20__factory.multicall, deployedAtBlock),
    staking: contract("0xStakingAddress", Staking__factory.connect, Staking__factory.multicall, 10000)
}

const bindings = {
  ERC20: bindings(ERC20__factory.connect, ERC20__factory.multicall)
}
```

### Network Contracts Registry

Once you have a mapping of contracts for each network you can instantiate the NetworkContractsRegistry to map
the contracts registries to a network.
```typescript
export interface MyAPINetworksMapping {
    [Network.MAINNET]: typeof ethereumMainnet,
    [Network.OPTIMISM]: typeof optimismMainnet
}

export const myApiContracts = new NetworksContractsRegistry<IMaiPeripherals, typeof bindings>()
myApiContracts.addNetwork(Network.MAINNET, ethereumMainnet);
myApiContracts.addNetwork(Network.OPTIMISM, optimismMainnet);
myApiContracts.setNamedFactories(bindings)
```

### Contracts Factory

The Contracts Factory uses the Providers Registry and the NetworkContractsRegistry to instantiate
contracts with typings support.

```typescript
const bundledApi = new ContractFactory(providers, myApiContracts)
```

### Using the ContractFactory

Querying a contract:
```typescript
const myErc20Token = bundledApi.forNetwork(Network.OPERA_MAINNET).getContractInstance("myErc20Token");
const symbol = myErc20Token.symbol()
```

Using multicall to batch calls:
```typescript
const multicallResults = bundledApi.forNetwork(Network.OPERA_MAINNET).multicall((get) => [
  get("myErc20Token").symbol(),
  get("myErc20Token").name()
])
```
npm package: @hovrcat/reorder-json
Description: Small tool used to reorder JSON keys alphabetically
Author: RaduB
Latest version: 1.1.6

# Reorder JSON
Small tool that reorders JSON keys alphabetically

## Installation
`npm i -g @hovrcat/reorder-json`

#### Testing
1. `
npm i
`

2. `
npm test
`


## Usage
#### From command line
| Option | Required | Description |
| --- | --- | --- |
| --i | ❌ | Path to the JSON file to be reordered |
| --o | ✔ | Where to save the reordered JSON file |

Example: `reorder -i /path/to/file.json`

#### In code
```javascript
const { Reorder } = require('@hovrcat/reorder-json');
const handler = new Reorder();
// then await the promise
await handler.reorderJSON(inputPath, outputPath);
// or handle it in the traditional way
handler.reorderJSON(inputPath, outputPath)
        .then(() => { 
            //... 
        });
```
npm package: @hovue/cli
Description: CLI tool for Hovue icons
Author: Hovue Contributors
Latest version: 0.0.2

# @hovue/cli

CLI tool for working with Hovue icons.

## Installation

```bash
pnpm add -D @hovue/cli
# or
npm install -D @hovue/cli
```

## Usage

### List available icons

```bash
npx hovue list
```

### Initialize configuration

```bash
npx hovue init
```

This creates a `hovue.config.json` file in your project root.

### Add icons to your project

```bash
npx hovue add ArrowRight Check Settings
```

This will copy the icon components to your project (default: `./src/components/icons`).

### Options

```bash
# Specify output directory
npx hovue add ArrowRight --output ./components/icons

# Specify target directory
npx hovue add ArrowRight --dir ./my-project
```

## Configuration

Create a `hovue.config.json` file:

```json
{
  "prefix": "Ho",
  "outputDir": "./src/components/icons",
  "importStyle": "named"
}
```
npm package: @hovue/icons
Description: Animated Vue icons with motion baked in
Author: Hovue Contributors
Latest version: 0.0.2

# @hovue/icons

Animated Vue icons with motion baked in.

## Installation

```bash
pnpm add @hovue/icons
# or
npm install @hovue/icons
```

## Usage

```vue
<script setup>
import { HoArrowRight, HoCheck, HoSettings } from '@hovue/icons'
</script>

<template>
  <HoArrowRight :size="24" animation="slide" />
  <HoCheck :size="32" color="green" animation="bounce" />
  <HoSettings :size="20" animation="rotate" />
</template>
```

## Props

All icons accept the following props:

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `size` | `number \| string` | `24` | Icon size in pixels |
| `color` | `string` | `'currentColor'` | Icon color (CSS color value) |
| `animation` | `'slide' \| 'bounce' \| 'rotate' \| 'pulse' \| 'fade'` | `'slide'` | Animation type on hover |
| `animationDuration` | `number` | `300` | Animation duration in milliseconds |

## Available Icons

- **Arrows**: ArrowRight, ArrowLeft, ArrowUp, ArrowDown
- **Chevrons**: ChevronRight, ChevronDown
- **Actions**: Check, X, Plus, Minus
- **Navigation**: Search, Menu, Home
- **User**: User, Settings, Bell, Mail
- **Media**: Play, Pause, Volume, Camera, Image, Music
- **Files**: File, Folder, Copy, Trash
- **System**: Download, Upload, Loader, Refresh, Sync
- **Time**: Clock, Calendar
- **UI**: Heart, Star

## Animations

Icons support CSS-based animations on hover:

- **slide** - Slides horizontally
- **bounce** - Bounces up and down
- **rotate** - Rotates 180 degrees
- **pulse** - Pulses in size
- **fade** - Fades in/out

## Tree Shaking

Icons are tree-shakeable. Import only what you need:

```vue
<script setup>
// ✅ Good - only imports what you use
import { HoArrowRight } from '@hovue/icons'

// ❌ Avoid - imports everything
import * as Icons from '@hovue/icons'
</script>
```

## TypeScript

Full TypeScript support with type definitions included.

## License

MIT
npm package: @hovue/nuxt
Description: Nuxt module for @hovue/icons with auto-import
Author: Hovue Contributors
Latest version: 0.0.2

# @hovue/nuxt

Nuxt module for [@hovue/icons](../icons) with auto-import support.

## Installation

```bash
pnpm add @hovue/icons @hovue/nuxt
```

## Usage

Add to your `nuxt.config.ts`:

```ts
export default defineNuxtConfig({
  modules: ['@hovue/nuxt'],
  hovue: {
    prefix: 'Ho' // Optional, defaults to 'Ho'
  }
})
```

## Auto-Import

Icons are automatically imported and available in your templates:

```vue
<template>
  <div>
    <HoArrowRight :size="24" animation="slide" />
    <HoCheck :size="32" color="green" />
    <HoSettings :size="20" />
  </div>
</template>
```

## Configuration

### `prefix`

Change the component prefix (default: `'Ho'`):

```ts
export default defineNuxtConfig({
  modules: ['@hovue/nuxt'],
  hovue: {
    prefix: 'Icon' // Now use <IconArrowRight />
  }
})
```

## Available Icons

See [@hovue/icons](../icons) for the complete list of available icons.
npm package: @how-to-react/lerna-semr-nwb-web-module
Description: Wen module for lerna
Author: Stephen Fraser
Latest version: 3.1.1

# nwb-web-module

[![Travis][build-badge]][build]
[![npm package][npm-badge]][npm]
[![Coveralls][coveralls-badge]][coveralls]

Describe nwb-web-module here.

[build-badge]: https://img.shields.io/travis/user/repo/master.png?style=flat-square
[build]: https://travis-ci.org/user/repo

[npm-badge]: https://img.shields.io/npm/v/npm-package.png?style=flat-square
[npm]: https://www.npmjs.org/package/npm-package

[coveralls-badge]: https://img.shields.io/coveralls/user/repo/master.png?style=flat-square
[coveralls]: https://coveralls.io/github/user/repo
npm package: @how-to-react/nwb-semantic-release
Description: NWB with semantic relase model
Author: Stephen Fraser
Latest version: 1.0.0

# NWB Semantic Release

[![Build Status](https://travis-ci.org/how-to-react/nwb-semantic-release.svg?branch=master)](https://travis-ci.org/how-to-react/nwb-semantic-release)
[![Coverage Status](https://coveralls.io/repos/github/how-to-react/nwb-semantic-release/badge.svg?branch=master)](https://coveralls.io/github/how-to-react/nwb-semantic-release?branch=master)

Minimum NWB repository with semantic releases.

## Recreating
- `$ nwb new web-module nwb-semantic-release`
- Updated `travis.yml` to use node version 7.9.0
- Added semantic release and various packages and configuration (see package.json)
- npm publish --access public
npm package: @howaboua/create-opencode-plugin
Description: OpenCode workflow pack that generates plugins via /create-plugin
Latest version: 1.0.1

# OpenCode Plugin Generator

This workflow pack enables OpenCode to generate its own TypeScript plugins. It bundles the SDK documentation, a slash command that triggers the workflow, and a required agent profile.

![plugin-creator](https://github.com/user-attachments/assets/9b9e7c64-cd2c-4136-8133-e41d020db914)

## Installation

Add to your `opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@howaboua/create-opencode-plugin@latest"]
}
```

OpenCode installs plugin dependencies automatically on next launch.

For local development:

```json
{
  "plugin": ["file:///absolute/path/to/create-opencode-plugin/dist/index.js"]
}
```

## Usage

Use the slash command to generate a new plugin:

```
/create-plugin "block any bash command that contains 'rm -rf'"
```

The command triggers the workflow, loading the agent and skill to look up the correct SDK hooks and generate TypeScript code.

## Components

*   **Command (`/create-plugin`)**: Triggers the workflow and passes your description to the agent.
*   **Skill (`create-opencode-plugin`)**: Contains the API reference, event types, and TypeScript definitions. This ensures the generated code compiles.
*   **Agent (`Plugin Creator`)**: Required specialized agent profile tuned for plugin development.

## Skill Configuration

> [!NOTE]
> The Plugin Creator agent has **1 skill enabled by default**: `create-opencode-plugin`. All other skills are blocked with `"*": "deny"`. This ensures the agent focuses on plugin development without context pollution.

The agent's YAML frontmatter controls skill access:

```yaml
permission:
  skill:
    create-opencode-plugin: allow
    '*': deny
```
npm package: @howaboua/opencode-glm-gemini-prompt-enhancer
Description: Enhances GLM-4.7 and Gemini models with a rigorous coding assistant system prompt
Latest version: 1.0.1

# @howaboua/opencode-glm-gemini-prompt-enhancer

Automatically enhances GLM-4.7 and Gemini models with a rigorous coding assistant system prompt.

## What It Does

This plugin prepends a comprehensive system prompt to GLM-4.7 and Gemini models, encouraging:

- **Precision** - Execute with accuracy, verify claims before stating
- **Honesty** - Stay grounded in verifiable facts, report actual actions
- **Persistence** - Try 3 approaches before escalating, complete tasks fully
- **Structured workflow** - Plan → Execute → Verify → Report
- **Error recovery** - Quote, diagnose, fix, verify

## Installation

Add to your `opencode.json`:

```json
{
  "plugin": ["@howaboua/opencode-glm-gemini-prompt-enhancer"]
}
```

OpenCode automatically installs plugin dependencies at runtime.

## Affected Models

- **GLM-4.7**: Any model with `glm-4.7` in its ID (e.g., `zai-coding-plan/glm-4.7`)
- **Gemini**: Any model with `gemini` in its ID

## Example Usage

```json
{
  "plugin": ["@howaboua/opencode-glm-gemini-prompt-enhancer"],
  "model": "gemini-2.0-flash-exp"
}
```

## Testing

1. Add to `opencode.json` (see Installation above)
2. Run OpenCode with a GLM-4.7 or Gemini model
3. Send a coding task and verify the response follows the structured format

Expected response format:
- **Structure:** Solution → rationale (if needed) → next steps
- **Tone:** Direct, concise, skip preambles
- **Verification:** Claims verified with tools before stating
- **Completion:** Tasks fully completed before yielding

## License

MIT
npm package: @howaboua/opencode-remember
Description: Semantic long-term memory for OpenCode with local embeddings
Latest version: 0.1.1

# Opencode Remember

Semantic long-term memory plugin for OpenCode. SQLite + local embeddings.

**Note**: This plugin prioritises speed and local-first operation using a lightweight embedding model. If you need sophisticated semantic understanding, look at enterprise solutions with larger models.

![opencode-remember](https://github.com/user-attachments/assets/a96265ca-da7e-4335-b09b-542ae5a03fce)

## Install

Add to `opencode.json`:

```json
{
  "plugin": ["@howaboua/opencode-remember@latest"]
}
```

First run downloads the embedding model (~88MB).

## Usage

Memories are injected after each user message:

```
<user_memories>
[important] User prefers functional components
[related] This project uses React 19
</user_memories>
```

### Tools

| Tool       | Description     |
| ---------- | --------------- |
| `remember` | Store a memory  |
| `recall`   | Search memories |
| `forget`   | Delete by ID    |

## Config

`.opencode/remember.jsonc`:

```jsonc
{
  "enabled": true,
  "scope": "both", // "global" | "project" | "both"
  "inject": {
    "count": 5,
    "highThreshold": 0.6,
  },
}
```

### Scope

| Value     | Search       | Save                         |
| --------- | ------------ | ---------------------------- |
| `project` | Project only | `.opencode/memory/`          |
| `global`  | Global only  | `~/.config/opencode/memory/` |
| `both`    | Both         | Agent decides per memory     |

## Storage

| Type    | Path                                         |
| ------- | -------------------------------------------- |
| Project | `.opencode/memory/memories.sqlite`           |
| Global  | `~/.config/opencode/memory/memories.sqlite`  |
| Model   | `~/.config/opencode/memory/models/` (shared) |

## License

MIT
npm package: @howaboua/opencode-roadmap-plugin
Description: Strategic roadmap planning and multi-agent coordination for OpenCode
Author: howaboua
Latest version: 0.2.1

# Opencode Roadmap Plugin

Persistent project roadmaps for OpenCode. Coordinates work across sessions and parallel Task tool subagents.

## Why Use This?

OpenCode's built-in todo is session-scoped—it disappears when you restart. Task tool subagents are stateless—they can't see each other's work.

This plugin solves both:

- **Persists to disk** — survives restarts, available across sessions
- **Shared context** — subagents read the same roadmap to understand the bigger picture
- **Concurrent awareness** — agents see what's `in_progress` and avoid conflicts

![opencode-roadmap](https://github.com/user-attachments/assets/e2479a72-ec65-457f-9503-bf2d01580c70)

## Installation

Add to your `opencode.json`:

```json
{
  "plugin": ["@howaboua/opencode-roadmap-plugin@latest"]
}
```

OpenCode installs it automatically on next launch.

## Tools

### `createroadmap`

Create or extend a project roadmap. Requires a feature list and a short spec for each feature.

```
"Create a roadmap with features: 1) Auth, 2) Profiles. Specs: Auth uses OAuth and must support password reset; Profiles needs avatar uploads and privacy settings"
```

- Features group related work (`"1"`, `"2"`, `"3"`) and include a brief spec
- Actions are markdown task list items (`- [ ] 1.01 ...`) within features
- New actions always start as `pending`
- Append-only: existing IDs never change

### `readroadmap`

View current state and progress.

```
"Show me the roadmap"
"What's the status of feature 2?"
```

Before delegating work to Task tool subagents, instruct them to read the roadmap first so they understand their assigned action within the broader plan.

### `updateroadmap`

Change action status or description. Each update includes a brief note appended to the updates section.

```
"Mark action 1.01 as in_progress — Drafted schema notes"
"Action 2.03 is completed — Added tests for edge cases"
```

**Statuses:** `pending` → `in_progress` → `completed` | `cancelled`

Transitions are flexible—you can revert if plans change. Only `cancelled` is terminal.

Auto-archives the roadmap when all actions reach `completed`.

## Coordinating Parallel Work

When multiple subagents work simultaneously:

1. Each reads the roadmap to see what's `in_progress`
2. Agents stay focused on their assigned action only
3. They avoid modifying files that belong to another `in_progress` action
4. Errors outside their scope get noted, not fixed

This prevents conflicts when subagents run in parallel.

## Workflow Example

```
You: "Plan out building a REST API with auth, users, and posts endpoints"

AI: Creates roadmap with 3 features, ~12 actions

You: "Implement feature 1"

AI: Reads roadmap → sees Feature 1 has 4 actions → uses todowrite for immediate steps → delegates to subagents → each subagent reads roadmap first → updates status when done
```

## Storage

- **Active:** Stored as a markdown roadmap alongside the project
- **Archived:** Snapshot archived when complete

## License

MIT
npm package: @howaboua/opencode-tps-counter
Description: OpenCode plugin that reports Latency and E2E TPS per assistant turn
Latest version: 0.1.0

# OpenCode TPS Counter Plugin

This plugin posts a compact generation speed line after assistant responses in OpenCode:

`▣ Lat.: <value>s | E2E TPS: <value>`

## What the metrics mean

- `E2E TPS`: Effective local throughput in this OpenCode session.
  - Formula: `(output tokens + reasoning tokens) / (effective end - turn start - merged tool execution time)`
  - `effective end` prefers the last streamed token time when available, and falls back to message completion time.
  - This is measured from OpenCode message/event timestamps, not provider-native telemetry.
- `Lat.`: Time to first token for the assistant turn.
  - Formula: `first streamed token time - turn start`
  - If streaming timing is unavailable, it shows `n/a`.

## How the plugin measures a turn

- The plugin reports only when an assistant message is finalized with `finish: "stop"`.
- It groups all assistant messages in that turn by `parentID` (tool-call steps plus the final assistant stop).
- It sums `output + reasoning` tokens across the grouped assistant messages.
- It tracks stream windows from both stored parts and live `message.part.updated` events so latency still works when part timing is incomplete.
- It merges overlapping tool runtimes and subtracts that merged tool time from the end-to-end duration.

## Important limitation

These numbers are based on OpenCode-local timing and token accounting. They are useful for relative comparisons in the same environment, but they will not always match provider dashboards (for example OpenRouter throughput) because provider-side queueing/transport internals are not exposed in plugin events.

Reliability is highest when a provider streams chunks continuously. If a provider buffers output and flushes large chunks (or nearly the full response) at once, the measured generation window becomes artificially short and the reported rate can spike.

Example: some Z.ai responses can arrive in bursts where most assistant text appears nearly at once. In that case, the displayed value is less representative of true model-side throughput. This behavior comes from provider streaming characteristics and is not fully fixable from plugin-side event timing.

## Trigger behavior

The plugin reports when an assistant message reaches `finish: "stop"` on `message.updated`. This is more reliable than waiting for `session.idle`.

## Install from npm

Add the plugin package to your OpenCode config. OpenCode installs npm plugins automatically.

Example `opencode.json`:

```json
{
  "plugin": ["@howaboua/opencode-tps-counter@^0.1.0"]
}
```

## Local development

Install dev dependencies:

```bash
bun install
```

Type-check the plugin:

```bash
bun x tsc --noEmit
```

Use local plugin wiring while developing:

```jsonc
{
  "plugin": ["file:///absolute/path/to/opencode-tps-counter/index.ts"]
}
```