open-index/open-npm huggingface dataset:
npm package: @i081732/easyenv
Description: The easiest way to share .env files with your team securely
Latest version: 0.1.2

<div align="center">

# 🔐 easyenv

**The easiest way to share .env files with your team securely.**

Stop sharing secrets over Slack. Stop losing .env files.
Encrypt, sync, and track your environment variables with Git.

[![npm version](https://img.shields.io/npm/v/@i081732/easyenv.svg)](https://www.npmjs.com/package/@i081732/easyenv)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

</div>

---

## 😩 The Problem

Every developer has experienced this:

- 🆕 New team member joins → spends **half a day** setting up `.env`
- 🔄 Someone adds a new variable → nobody knows → **app breaks**
- 💬 `.env` shared over Slack/Email → **security nightmare**
- 📝 `.env.example` is always **outdated**

## ✅ The Solution

```bash
npx @i081732/easyenv init     # generate encryption key
easyenv push                   # encrypt & save to git
easyenv pull                   # teammate restores .env
easyenv diff                   # compare .env vs .env.example
easyenv check                  # find missing variables
easyenv log                    # see who changed what
npm package: @i0p1/standard-result
Description: A standardized result type for TypeScript
Author: i0p1
Latest version: 1.0.1

# Standard Result

A standardized result type for TypeScript with full CommonJS and ES Module support.

## Installation

```bash
npm install standard-result
```

## Usage

### TypeScript / ES Module

```typescript
import { createResult, type Result, type BaseOptions } from "standard-result";

// Create a success result
const successResult = createResult({
  status: "success",
  data: { userId: 123 },
  message: "User created successfully",
});

// Create an error result
const errorResult = createResult({
  status: "error",
  message: "User not found",
});
```

### CommonJS

```javascript
const { createResult } = require("standard-result");

const result = createResult({
  status: "success",
  data: { value: 42 },
});
```

## API

### Types

- `Status`: `"error" | "success"`
- `Level`: `"error" | "success" | "warn" | "info"`
- `BaseOptions`: Configuration object for creating results
- `Result<O>`: The result type with inferred properties

### Functions

#### `createResult<O extends BaseOptions>(options: O): Result<O>`

Creates a standardized result object with the following properties:

- `status`: The status of the result
- `level`: The severity level (defaults to status if not specified)
- `timestamp`: ISO timestamp string
- `data`: Optional data payload
- `message`: Optional message string

## License

MIT
npm package: @i0san/artifact-optimizer
Description: A webpack plugin script that generates an optimized json file from smart contract artifacts. A list of contract names, addresses and ABIs.
Author: IoSan
Latest version: 1.0.0

# artifact-optimizer

A webpack plugin script that generates an optimized json file from smart contract artifacts. A list of contract names, addresses and ABIs.

This greately decreases the import file sizes compared to standard auto-generated artifact files from Hardhat or Truffle.

[Demo](https://codesandbox.io/p/sandbox/artifact-optimizer-34t3md)

## Installation

```bash
npm install @i0san/artifact-optimizer
```

## Usage
To re-create the result, delete the existing file before re-building (to prevent infinite rebuilding if in watch mode).

```js
const ArtifactOptimizer = require("@i0san/artifact-optimizer");

Webpack.config = {
  plugins: [
    new ArtifactOptimizer({
      inputDirs: ["./my-directory1", "./my-directory2"],
      outputDir: "./",
      outputFileName: "contractsWithABIs.json",
    }),
  ],
};
```

## Result

./contractsWithABIs.json

```js
[
    {
        "name": "Contract1",
        "address": "0x00..."
        "abi": [...]
    },
    ...
]
```
npm package: @i0san/block-timer
Description: A multichain counter. A React component library.
Author: IoSan
Latest version: 1.0.7

# block-timer

A multichain counter. A React component library.

V1 - Counts down to a future time defined in number of blocks on a specific Blockchain network.

[Demo](https://codesandbox.io/s/i0san-block-timer-zjqvjg)

## Install

```bash
npm install @i0san/block-timer
```

## Usage

```js
import { useBlockCountdown } from "@i0san/block-timer";

function MyApp() {
  // Set target date 100 blocks ahead from now (Bitcoin network)
  const { days, hours, minutes, seconds } = useBlockCountdown(100, "bitcoin");
  return (
    <>
      {days}days {hours}hours {minutes}minutes {seconds}seconds
    </>
  );
}
```

## Supported networks

```js
"bitcoin"
"ethereum"
"goerli"
"polygon"
"mumbai"
"bsc"
"bsc-testnet"
"cardano"
"cardano-testnet"
"solana"
"dogecoin"
"fantom"
"harmony"
"avalanche"
"avalanche-testnet"
"arbitrum"
"arbitrum-testnet"
"optimism"
"optimism-testnet"
// add more blockchain networks and their average block times as needed
```

## Planned features
- find a free API to fetch current average block time for a specific network
- add "startBlock" param
- add "endBlock" param
- add "startTimestamp" param
- add "endTimestamp" param

## Reference
[The complete guide to publish React hook as NPM package](https://igorluczko.medium.com/the-complete-guide-to-publish-react-hook-as-npm-package-880049829e89)
npm package: @i0san/hardhat-nextjs
Description: Hardhat plugin for generating a NextJS app with contract function and events implemented as hooks.
Author: IoSan
Latest version: 1.0.0

# hardhat-nextjs-plugin

Hardhat plugin that generates React hooks for all smart contract functions and events.


## About

This plugin allows a smart contract developer to generate React implementations of all the smart contract functions and events. 

React hooks or the whole NextJS project can then be shared with the dApp developer and jumpstart the development process.

The plugin also generates an optimized ABI files and copies then along with React Hooks.

To be able to use the hooks, the developer needs to enter the contract address into each abi file.


## Installation
1. Install the dependencies:

```bash
npm install @i0san/hardhat-nextjs
```

2. Import the plugin in your `hardhat.config.js`:

```ts
import "@i0san/hardhat-nextjs";
```


## Tasks

This plugin adds the "_nextjs_" task to Hardhat. To see the info about the task options run:

```bash
npx hardhat help nextjs
```

## Usage

To use the task, run the task after the contracts have been compiled and artifacts generated.

```bash
npx hardhat nextjs
```

This will create a new folder "/nextjs-app" with the app and all the hooks and a usage page.

## Configuration

```
Usage: hardhat [GLOBAL OPTIONS] nextjs [--hooks-only <BOOLEAN>] [--skip-contracts <STRING>]

OPTIONS:

  --hooks-only          Generate React Hooks only. (default: false)
  --skip-contracts      Array of contract names to skip. Format: "[\"Contract1", \"Contract2"]". Optional.

nextjs: Generate NextJS app with implemented contract functions and events.
```


## License
[MIT](https://github.com/i0san/hardhat-nextjs/blob/main/LICENSE)


## Author
IoSan - iosan@protonmail.com
npm package: @i14a/logger
Description: Fancy logger for my projects
Author: i14a
Latest version: 1.0.2

# FancyLogger

Simple console logger that prints boxed, colored messages.

Usage:

Install:

```bash
npm install @i14a/logger
```

Import:

```ts
import FancyLogger from '@i14a/logger';

FancyLogger.success('Done');
```
npm package: @i18n-agent/cli
Description: Terminal client for i18n-agent translation service
Author: FatCouple OU
Latest version: 1.0.2

# @i18n-agent/cli

Terminal client for the i18n-agent translation service. Translate text and files directly from your terminal.

## Install

```bash
npm install -g @i18n-agent/cli
```

Requires Node.js >= 18.

## Setup

```bash
# Save your API key (get one at https://app.i18nagent.ai)
i18nagent login
```

Or set via environment variable (for CI/CD):
```bash
export I18N_AGENT_API_KEY=your-key-here
```

## Usage

### Translate text
```bash
i18nagent translate "Hello world" --lang es
i18nagent translate "Hello world" --lang es,fr,ja
```

### Translate files
```bash
i18nagent translate ./locales/en.json --lang es,fr
i18nagent translate ./docs/guide.md --lang de --namespace my-project
```

### Interactive mode
```bash
i18nagent translate     # prompts for input
i18nagent tui           # full interactive menu
```

### Check job status
```bash
i18nagent status <jobId>
```

### Download translations
```bash
i18nagent download <jobId> --output ./locales
```

### Resume failed jobs
```bash
i18nagent resume <jobId>
```

### Check credits
```bash
i18nagent credits
```

### Upload existing translations
```bash
i18nagent upload ./de.json --source en --target de --namespace my-project
```

### List supported languages
```bash
i18nagent languages
```

### Analyze content
```bash
i18nagent analyze ./en.json --lang es
```

## JSON output

All commands support `--json` for machine-readable output:
```bash
i18nagent translate "Hello" --lang es --json
i18nagent credits --json
```

## Config

Config is stored at `~/.config/i18nagent/config.json`:
```json
{
  "apiKey": "i18n_...",
  "defaultLanguages": ["es", "fr"],
  "defaultNamespace": "my-project"
}
```

Environment variable `I18N_AGENT_API_KEY` takes priority over config file.

## Binary distribution

See [docs/BINARY_DISTRIBUTION.md](docs/BINARY_DISTRIBUTION.md) for standalone binary packaging.

## License

MIT
npm package: @i18n-audit/javascript
Description: Framework-agnostic i18n audit CLI for JavaScript codebases
Latest version: 0.1.0

# @i18n-audit/javascript

Framework-agnostic i18n audit CLI for JavaScript codebases.

Works for frontend and backend JS projects: React, Vue, Svelte, Next, Nuxt, Node APIs, jQuery apps, and mixed repos.

## Features

- Configurable scan patterns from `.env`
- Configurable scan paths, lang paths, and excludes
- Configurable file extensions (empty means scan all files)
- Translation loading from JSON, YAML, and JS module files
- Nested key flattening
- Missing and unused key reporting per locale
- Dynamic key warnings
- Auto-populate missing keys with `{key}` and `{locale}` placeholder template
- JSON and clean Tailwind HTML reports

## Install

```bash
npm install @i18n-audit/javascript --save-dev
```

## Usage

```bash
npx i18n-audit-js
```

JSON output:

```bash
npx i18n-audit-js --format json
```

Generate HTML report:

```bash
npx i18n-audit-js --html --html-output var/i18n-audit-latest.html
```

Auto-populate missing:

```bash
npx i18n-audit-js --fill-missing
```

## .env Configuration

All configuration is `.env` driven. See `.env.example`.

Example values:

- `I18N_AUDIT_SCAN_PATHS=src,app,components,views,templates`
- `I18N_AUDIT_EXCLUDE_PATHS=node_modules,vendor,.git,dist,build,coverage`
- `I18N_AUDIT_SCAN_EXTENSIONS=js,jsx,mjs,cjs,ts,tsx,vue,svelte,html,php`
- `I18N_AUDIT_SCAN_PATTERNS=t,i18n.t,$t,__,trans,gettext`
- `I18N_AUDIT_LANG_PATHS=locales,i18n,lang,translations`
- `I18N_AUDIT_LOCALES=en,de,sr`
- `I18N_AUDIT_AUTO_POPULATE_PLACEHOLDER=Missing translation: {key} for locale: {locale}`

## CLI Options

- `--env-file <path>`
- `--locales <csv>`
- `--paths <csv>`
- `--exclude <csv>`
- `--extensions <csv>`
- `--patterns <csv>`
- `--lang-paths <csv>`
- `--format table|json`
- `--output <path>`
- `--html`
- `--html-output <path>`
- `--fill-missing`
- `--fill-template <value>`
- `--fill-format json|yaml|js`
- `--fail-on-missing`
- `--fail-on-unused`
npm package: @i18n-bakery/tray
Description: The Silver Tray. Delivers i18n-bakery capabilities directly to AI agents via the Model Context Protocol (MCP), making translation workflows effortlessly accessible.
Author: Arturo Sáenz
Latest version: 1.0.9

# @i18n-bakery/tray 🍽️

> The Silver Tray — delivers the **i18n-bakery** kitchen directly to AI agents via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).

`tray` makes translation workflows accessible to any MCP-compatible AI agent (Claude, Cursor, Copilot, etc.), enabling fully automated i18n pipelines without human intervention.

---

## What it does

Instead of a human running CLI commands, an AI agent can:

1. **Detect** missing translations across all locales
2. **Extract** new keys after UI changes
3. **Write** translated strings directly to locale files
4. **Compile** production bundles with hashing and minification

## Tools

| Tool | Description |
|---|---|
| `fry_batter` | Scans source files for `t()` calls and writes keys to locale files |
| `bake_bundle` | Compiles locale files into optimized production bundles |
| `check_pantry` | Status report: completion %, missing keys per locale |
| `update_recipe` | Writes/updates a single translation key in a locale file |

## Typical AI Agent Workflow

```
1. check_pantry   → "es-MX is 60% complete, missing 12 keys"
2. fry_batter     → "Found 3 new keys after the latest component changes"
3. update_recipe  → write each translated key
4. bake_bundle    → compile for production
```

## Installation

```bash
pnpm add @i18n-bakery/tray
```

## Usage

### As an MCP Server (stdio)

```bash
# Start the MCP server via stdio
npx i18n-bakery-tray
```

### Claude Desktop Configuration

```json
{
  "mcpServers": {
    "i18n-bakery": {
      "command": "npx",
      "args": ["i18n-bakery-tray"],
      "cwd": "/path/to/your/project"
    }
  }
}
```

### Programmatic Usage

```ts
import { createTrayServer } from '@i18n-bakery/tray';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = createTrayServer();
const transport = new StdioServerTransport();
await server.connect(transport);
```

## Architecture

Follows Clean Architecture with SOLID principles:

```
src/
  domain/         Pure types — no runtime dependencies
  use-cases/      Orchestration: BatterUseCase, BakeUseCase, PantryUseCase, RecipeUseCase
  adapters/       Infrastructure: SilentLogger
  tools/          Atomic MCP tool registrations (one file per tool)
  shared/         DRY utilities: flatten/unflatten, deep key access, path validation
  index.ts        Server assembly — pure DI, no business logic
```

## Security

- All user-provided path segments are validated against directory traversal
- Prototype pollution is prevented at every object merge
- Encryption key is required when encryption is enabled (validated at tool level)