open-index/open-npm huggingface dataset:
npm package: @scutoid/react
Description: [<img src="https://scutoid-react.vercel.app/icon/256x256.png" alt="Scutoid React" />](https://scutoid-react.vercel.app/components)
Author: kader
Latest version: 0.2.4

# [Scutoid React](https://scutoid-react.vercel.app/components "Scutoid React")

[<img src="https://scutoid-react.vercel.app/icon/256x256.png" alt="Scutoid React" />](https://scutoid-react.vercel.app/components)

## 📦 Install

```bash
npm install @scutoid/react
```

```bash
yarn add @scutoid/react
```

## 🔧 Usage

```jsx
import { Button } from "@scutoid/react";

const App = () => (
  <>
    <Button type="Outlined">I'm Button</Button>
  </>
);
```

## 📣 Styled-Components

`@scutoid/react` is written in Styled-Components with complete definitions.
## 📣 TypeScript

`@scutoid/react` is written in TypeScript with complete definitions.


[Go To documentation →](https://scutoid-react.vercel.app/components)
npm package: @scuton/cron-explain
Description: Explain cron expressions in plain English. CLI + Library.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/cron-explain

Explain cron expressions in plain English. Works as both a CLI tool and a library.

## Installation

```bash
npm install @scuton/cron-explain
```

Global install for CLI usage:

```bash
npm install -g @scuton/cron-explain
```

## CLI Usage

```bash
cron-explain "*/5 * * * *"
# Every 5 minutes

cron-explain "0 9 * * 1-5"
# At 9:00 AM, Monday through Friday

cron-explain "0 0 1 * *"
# At 12:00 AM, on day 1, of every month
```

## API Usage

```typescript
import { explain } from '@scuton/cron-explain';

explain('*/5 * * * *');   // "Every 5 minutes"
explain('0 9 * * 1-5');   // "At 9:00 AM, Monday through Friday"
explain('0 0 1 * *');     // "At 12:00 AM, on day 1, of every month"
```

### CommonJS

```javascript
const { explain } = require('@scuton/cron-explain');

console.log(explain('0 12 * * *')); // "At 12:00 PM"
```

## Examples

| Expression       | Explanation                                        |
| ---------------- | -------------------------------------------------- |
| `* * * * *`      | Every minute                                       |
| `*/5 * * * *`    | Every 5 minutes                                    |
| `*/15 * * * *`   | Every 15 minutes                                   |
| `0 */2 * * *`    | Every 2 hours                                      |
| `0 9 * * *`      | At 9:00 AM                                         |
| `0 12 * * *`     | At 12:00 PM                                        |
| `30 9 * * 1-5`   | At 9:30 AM, Monday through Friday                  |
| `0 0 1 * *`      | At 12:00 AM, on day 1, of every month              |
| `0 0 1 6 *`      | At 12:00 AM, on day 1, in June, of every month     |
| `0 9 * * 1,3,5`  | At 9:00 AM, on Monday, Wednesday, Friday           |

## Supported Cron Syntax

Standard 5-field cron expressions:

```
┌───────── minute (0-59)
│ ┌───────── hour (0-23)
│ │ ┌───────── day of month (1-31)
│ │ │ ┌───────── month (1-12)
│ │ │ │ ┌───────── day of week (0-6, Sunday=0)
│ │ │ │ │
* * * * *
```

Supported patterns:
- `*` — any value
- `N` — specific value
- `N,M` — list of values
- `N-M` — range of values
- `*/N` — every N

## License

MIT - Scuton Technology
npm package: @scuton/dotenv-guard
Description: Validate env vars, sync .env with .env.example, prevent secret leaks. Zero dependencies.
Author: Scuton Technology
Latest version: 1.0.0

<div align="center">

# dotenv-guard

**Validate env vars. Sync .env files. Prevent secret leaks.**

**Zero dependencies.** Works with any Node.js project.

[![npm](https://img.shields.io/npm/v/dotenv-guard)](https://www.npmjs.com/package/dotenv-guard)
[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
[![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)](package.json)

</div>

---

## Install

```bash
npm install dotenv-guard
```

## Quick Start

Add one line to your app entry:

```typescript
import 'dotenv-guard/auto'; // App won't start if .env is missing required variables
```

Or use the CLI:

```bash
npx dotenv-guard sync          # .env vs .env.example
npx dotenv-guard validate      # Check types
npx dotenv-guard leak-check    # Find leaked secrets
npx dotenv-guard init          # Create .env.example + .gitignore
npx dotenv-guard install-hook  # Pre-commit hook
```

## Type Hints

Add type hints in .env.example comments:

```bash
DATABASE_URL=postgresql://... # type:url
PORT=3000 # type:port
DEBUG=false # type:boolean
NODE_ENV=development # enum:development,staging,production
REDIS_URL= # type:url optional
```

## Programmatic API

```typescript
import { guard, syncCheck, validate, checkLeaks } from 'dotenv-guard';

// Quick guard — exits if missing vars
guard();

// Detailed sync check
const sync = syncCheck();
console.log(sync.missing); // ['API_KEY', 'SECRET']

// Custom validation
const errors = validate(process.env, [
  { key: 'PORT', type: 'port', required: true },
  { key: 'NODE_ENV', type: 'enum', enum: ['dev', 'staging', 'prod'] },
]);

// Leak detection
const leaks = checkLeaks();
if (leaks.leaks.length > 0) console.warn('Secrets leaked!');
```

## Why?

- **Missing env vars** crash your app at runtime -> dotenv-guard catches them at startup
- **Type mismatches** (port as string, URL without protocol) -> dotenv-guard validates
- **.env committed to git** -> dotenv-guard blocks it with pre-commit hook
- **Zero dependencies** -> no supply chain risk, tiny bundle

## License

MIT - [Scuton Technology](https://scuton.com)
npm package: @scuton/git-whoami
Description: Show your git identity, SSH keys, GPG status, and remote config at a glance.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/git-whoami

Show your git identity, SSH keys, GPG status, and remote config at a glance.

## Install

```bash
npm install -g @scuton/git-whoami
```

Or use directly with npx:

```bash
npx @scuton/git-whoami
```

## Usage

### CLI

```bash
git-whoami
```

Output:

```
  Git Identity
    Name:     John Doe
    Email:    john@example.com
    Scope:    global

  SSH
    Key:      ~/.ssh/id_ed25519 (ED25519)
    Agent:    running (1 keys loaded)
    GitHub:   ✓ authenticated

  GPG
    Key:      ABC123DEF456
    Signing:  enabled

  Remote (origin)
    URL:      git@github.com:user/repo.git
    Protocol: SSH

  Config
    Default branch:  main
    Auto CRLF:       false
    Pull rebase:     true
```

### JSON output

```bash
git-whoami --json
```

Returns a structured JSON object with all identity information.

### Programmatic API

```typescript
import { whoami } from '@scuton/git-whoami';

const result = whoami();
console.log(result.identity.name);
console.log(result.ssh.githubAuth);
```

Individual functions are also available:

```typescript
import {
  getIdentity,
  getSSHInfo,
  getGPGInfo,
  getRemoteInfo,
  getGitConfig,
} from '@scuton/git-whoami';

const identity = getIdentity();
// { name: 'John Doe', email: 'john@example.com', scope: 'global' }

const ssh = getSSHInfo();
// { keyPath: '~/.ssh/id_ed25519', keyType: 'ED25519', agentRunning: true, keysLoaded: 1, githubAuth: true }

const gpg = getGPGInfo();
// { keyId: 'ABC123DEF456', signingEnabled: true }

const remote = getRemoteInfo();
// { url: 'git@github.com:user/repo.git', protocol: 'SSH' }

const config = getGitConfig();
// { defaultBranch: 'main', autoCRLF: 'false', pullRebase: 'true' }
```

## Options

| Flag       | Description                          |
| ---------- | ------------------------------------ |
| `--json`   | Output all info as JSON              |
| `--help`   | Show help message                    |

## License

MIT - Scuton Technology
npm package: @scuton/json-diff
Description: Compare two JSON files and show differences. Color-coded terminal output.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/json-diff

Compare two JSON files and show differences with color-coded terminal output.

Works as both a **CLI tool** and a **programmatic library**.

## Installation

```bash
# Global CLI
npm install -g @scuton/json-diff

# Project dependency
npm install @scuton/json-diff
```

## CLI Usage

```bash
json-diff <file1.json> <file2.json>
```

### Example

```bash
$ json-diff old-config.json new-config.json

  + added:    database.pool = 10
  - removed:  debug
  ~ changed:  server.port: 3000 → 8080

  Summary: 1 added, 1 removed, 1 changed
```

### Options

| Flag           | Description          |
| -------------- | -------------------- |
| `-h`, `--help` | Show help            |
| `--no-color`   | Disable color output |

Set the `NO_COLOR` environment variable to disable colors globally.

## Programmatic API

```typescript
import { diffJson } from '@scuton/json-diff';

const result = diffJson(
  { server: { port: 3000 }, debug: true },
  { server: { port: 8080 }, database: { pool: 10 } }
);

console.log(result.identical); // false
console.log(result.added);     // [{ path: 'database', type: 'added', newValue: { pool: 10 } }]
console.log(result.removed);   // [{ path: 'debug', type: 'removed', oldValue: true }]
console.log(result.changed);   // [{ path: 'server.port', type: 'changed', oldValue: 3000, newValue: 8080 }]
```

## API Types

```typescript
interface DiffEntry {
  path: string;
  type: 'added' | 'removed' | 'changed';
  oldValue?: any;
  newValue?: any;
}

interface DiffResult {
  added: DiffEntry[];
  removed: DiffEntry[];
  changed: DiffEntry[];
  identical: boolean;
}

function diffJson(a: any, b: any): DiffResult;
function formatValue(val: any): string;
```

## Features

- Deep recursive comparison of nested objects and arrays
- Dot-notation paths for easy identification (`server.port`, `items[2]`)
- Color-coded output: green (added), red (removed), yellow (changed)
- Zero dependencies at runtime
- Dual CJS/ESM output with TypeScript declarations

## License

MIT - Scuton Technology
npm package: @scuton/kill-port
Description: Kill any process running on a specified port. Cross-platform.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/kill-port

Kill any process running on a specified port. Cross-platform (Windows, macOS, Linux).

## Install

```bash
npm install @scuton/kill-port
```

## CLI Usage

```bash
# Kill a single port
npx @scuton/kill-port 3000

# Kill multiple ports
npx @scuton/kill-port 3000 8080 5432
```

## Programmatic API

```typescript
import { killPort, getProcessOnPort } from '@scuton/kill-port';

// Kill process on port
const result = killPort(3000);
// { port: 3000, killed: true, pid: 12345 }

// Check what's running on a port
const info = getProcessOnPort(3000);
// { pid: 12345, name: 'node' }
```

## API

### `killPort(port: number): KillResult`

Kills the process listening on the given port.

### `getProcessOnPort(port: number): { pid: number; name?: string } | null`

Returns info about the process on the given port, or `null` if the port is free.

## Cross-platform

- **Windows**: Uses `netstat -ano` + `taskkill`
- **macOS/Linux**: Uses `lsof` + `kill -9`

## License

MIT © Scuton Technology
npm package: @scuton/license-gen
Description: Generate LICENSE files from your terminal. MIT, Apache-2.0, GPL-3.0, BSD, ISC and more.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/license-gen

Generate LICENSE files from your terminal. Supports MIT, Apache-2.0, GPL-3.0, BSD, ISC, and more.

## Install

```bash
npm install -g @scuton/license-gen
```

## CLI Usage

```bash
# Generate MIT license (auto-detect author from git)
npx @scuton/license-gen mit

# Specify author and year
npx @scuton/license-gen apache-2.0 --author "John Doe" --year 2026

# List all available licenses
npx @scuton/license-gen --list

# Custom output path
npx @scuton/license-gen mit --output ./docs/LICENSE
```

## Programmatic API

```typescript
import { generateLicense, listLicenses } from '@scuton/license-gen';

// Generate license text
const text = generateLicense({
  license: 'mit',
  author: 'John Doe',
  year: '2026',
});

// List available licenses
const licenses = listLicenses();
// ['mit', 'apache-2.0', 'gpl-3.0', 'bsd-2-clause', 'bsd-3-clause', 'isc', 'unlicense', 'mpl-2.0']
```

## Supported Licenses

| ID | Name |
|---|---|
| `mit` | MIT License |
| `apache-2.0` | Apache License 2.0 |
| `gpl-3.0` | GNU GPL v3 |
| `bsd-2-clause` | BSD 2-Clause |
| `bsd-3-clause` | BSD 3-Clause |
| `isc` | ISC License |
| `unlicense` | The Unlicense |
| `mpl-2.0` | Mozilla Public License 2.0 |

## License

MIT © Scuton Technology
npm package: @scuton/ms-convert
Description: Convert between human-readable time strings and milliseconds. Bidirectional.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/ms-convert

Convert between human-readable time strings and milliseconds. Bidirectional.

## Installation

```bash
npm install @scuton/ms-convert
```

## Usage

```typescript
import { toMs, toHuman } from '@scuton/ms-convert';

// String to milliseconds
toMs('2h 30m');    // 9000000
toMs('1d 12h');    // 129600000
toMs('1.5h');      // 5400000
toMs('500ms');     // 500
toMs('1mo');       // 2592000000
toMs('1y');        // 31536000000

// Milliseconds to human-readable string
toHuman(9000000);                        // '2h 30m'
toHuman(129600000);                      // '1d 12h'
toHuman(90061000);                       // '1d 1h 1m 1s'

// Short format (largest unit only)
toHuman(90061000, { short: true });      // '1d'

// Long format (full words)
toHuman(3600000, { long: true });        // '1 hour'
toHuman(7200000, { long: true });        // '2 hours'
```

## API

### `toMs(input: string): number`

Converts a human-readable time string to milliseconds.

- Supports compound strings like `'2h 30m'`
- Supports decimal values like `'1.5h'`
- Case insensitive
- Throws `Error` if no valid time units are found

### `toHuman(ms: number, options?: ToHumanOptions): string`

Converts milliseconds to a human-readable string.

#### Options

| Option  | Type      | Default | Description                          |
|---------|-----------|---------|--------------------------------------|
| `short` | `boolean` | `false` | Return only the largest unit         |
| `long`  | `boolean` | `false` | Use full unit names (e.g., "hours")  |

## Supported Units

| Unit | Short | Long         | Milliseconds      |
|------|-------|--------------|--------------------|
| ms   | `ms`  | millisecond  | 1                  |
| s    | `s`   | second       | 1,000              |
| m    | `m`   | minute       | 60,000             |
| h    | `h`   | hour         | 3,600,000          |
| d    | `d`   | day          | 86,400,000         |
| w    | `w`   | week         | 604,800,000        |
| mo   | `mo`  | month        | 2,592,000,000 (30d)|
| y    | `y`   | year         | 31,536,000,000(365d)|

## License

MIT - Scuton Technology
npm package: @scuton/port-finder
Description: Find an available port. Starts from a base port and increments.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/port-finder

Find an available port. Starts from a base port and increments until one is free. Zero dependencies.

## Install

```bash
npm install @scuton/port-finder
```

## Usage

```typescript
import { findPort, isPortFree } from '@scuton/port-finder';

// Find first available port (starts at 3000)
const port = await findPort();

// Start from a specific port
const port = await findPort(8080);

// Specify a range
const port = await findPort({ start: 3000, end: 4000 });

// Check if a port is free
const free = await isPortFree(3000); // true/false
```

## API

### `findPort(options?): Promise<number>`

Find the first available port. Accepts a start number or options object.

### `isPortFree(port, host?): Promise<boolean>`

Check if a specific port is available.

## License

MIT © Scuton Technology
npm package: @scuton/readme-forge
Description: AI-powered README generator. Analyze your codebase and generate professional documentation in seconds.
Author: Scuton Technology
Latest version: 1.0.1

<div align="center">

# readme-forge

**AI-powered README generator. One command. Professional docs.**

[![npm](https://img.shields.io/npm/v/readme-forge)](https://www.npmjs.com/package/readme-forge)
[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-3178c6)](https://www.typescriptlang.org/)
[![CI](https://github.com/scuton-technology/readme-forge/actions/workflows/ci.yml/badge.svg)](https://github.com/scuton-technology/readme-forge/actions/workflows/ci.yml)

</div>

---

## Why?

Writing a good README is tedious. readme-forge analyzes your project — package.json, file structure, dependencies, git history — and generates a professional README in seconds using Claude AI.

## Install

```bash
npm install -g readme-forge
```

## Setup

Set your Anthropic API key:

```bash
export ANTHROPIC_API_KEY=sk-ant-...
```

Get a key at [console.anthropic.com](https://console.anthropic.com/settings/keys)

## Usage

```bash
# Generate README for current project
readme-forge

# Choose template style
readme-forge generate --template minimal
readme-forge generate --template detailed

# Preview without writing
readme-forge generate --dry-run

# Check existing README quality
readme-forge check

# Add badges to README
readme-forge badge

# Generate table of contents
readme-forge toc
```

## Commands

| Command | Description | Needs API Key |
|---------|-------------|:---:|
| `readme-forge generate` | Generate README from project analysis | Yes |
| `readme-forge check` | Score your existing README (A+ to F) | No |
| `readme-forge badge` | Auto-detect and add project badges | No |
| `readme-forge toc` | Generate table of contents | No |

## Templates

**minimal** — Title, description, install, usage, license. Nothing more.

**standard** (default) — Badges, features, install, usage, contributing, license.

**detailed** — Everything + TOC, tech stack table, project structure, env vars, deployment.

## How it works

1. Scans your project: package.json, file structure, dependencies, git info
2. Detects language, framework, tools, CI/CD setup
3. Sends analysis to Claude (your API key, your data)
4. Returns clean Markdown — no fluff, no hallucination

Your code is NOT sent to the API. Only metadata (file names, package names, scripts) is sent.

## Privacy

- Your source code stays local. Only project metadata is sent to Anthropic's API.
- Your API key is used directly — we don't proxy or store anything.
- `check`, `badge`, and `toc` commands work 100% offline.

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md)

## License

MIT — [Scuton Technology](https://scuton.com)

---

<div align="center">
<sub>Built with ❤️ by Scuton Technology</sub>
</div>
npm package: @scuton/retry-fn
Description: Retry any async function with exponential backoff. Zero dependencies.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/retry-fn

Retry any async function with exponential backoff. Zero dependencies. TypeScript first.

## Install

```bash
npm install @scuton/retry-fn
```

## Usage

```typescript
import { retry } from '@scuton/retry-fn';

const data = await retry(() => fetch('https://api.example.com/data'), {
  retries: 3,
  delay: 1000,
  backoff: 2,
  maxDelay: 10000,
  onRetry: (err, attempt) => console.log(`Attempt ${attempt} failed`),
});
```

## API

### `retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>`

Options:
- `retries` — max retry count (default: 3)
- `delay` — initial delay in ms (default: 1000)
- `backoff` — exponential factor (default: 2)
- `maxDelay` — maximum delay cap in ms (default: 30000)
- `timeout` — per-attempt timeout in ms
- `retryOn` — filter function: `(error) => boolean`
- `onRetry` — callback: `(error, attempt) => void`

## License

MIT © Scuton Technology
npm package: @scuton/safe-json
Description: Safe JSON parse & stringify. Never throws. Returns default value on error.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/safe-json

Safe JSON parse & stringify. Never throws. Returns default value on error.

## Install

```bash
npm install @scuton/safe-json
```

## Usage

```typescript
import { safeParse, safeStringify, isJSON, jsonClone } from '@scuton/safe-json';

// Parse safely
safeParse('{"valid": true}');           // { valid: true }
safeParse('invalid json');               // undefined
safeParse('invalid json', { fallback: {} }); // {}
safeParse<User>('{"name":"John"}');      // typed result

// Stringify safely
safeStringify({ key: 'value' });         // '{"key":"value"}'
safeStringify(circularObj);              // undefined (no crash)
safeStringify(data, { pretty: true });   // formatted JSON

// Check if string is valid JSON
isJSON('{"valid": true}');  // true
isJSON('nope');             // false

// Deep clone via JSON
const clone = jsonClone({ nested: { value: 1 } });
```

## API

### `safeParse<T>(input: string, options?): T | undefined`

Parse JSON safely. Returns `undefined` (or `fallback`) on error.

Options:
- `fallback?: T` — value to return on parse error
- `reviver?: (key, value) => any` — JSON.parse reviver

### `safeStringify(value: any, options?): string | undefined`

Stringify safely. Returns `undefined` (or `fallback`) on error (e.g., circular refs).

Options:
- `pretty?: boolean` — indent with 2 spaces
- `replacer?: (key, value) => any` — JSON.stringify replacer
- `fallback?: string` — value to return on error

### `isJSON(input: string): boolean`

Returns `true` if the string is valid JSON.

### `jsonClone<T>(value: T): T | undefined`

Deep clone a value via JSON serialization.

## License

MIT © Scuton Technology
npm package: @scuton/slug-gen
Description: URL-safe slug generator with Unicode support. Turkish, Arabic, Cyrillic, CJK.
Author: Scuton Technology
Latest version: 1.0.0

# @scuton/slug-gen

URL-safe slug generator with comprehensive Unicode support. Zero dependencies.

## Install

```bash
npm install @scuton/slug-gen
```

## Usage

```typescript
import { slug } from '@scuton/slug-gen';

slug('Hello World');           // 'hello-world'
slug('Türkçe Karakterler');    // 'turkce-karakterler'
slug('Привет мир');            // 'privet-mir'
slug('café résumé');           // 'cafe-resume'
slug('Über Straße');           // 'ueber-strasse'
slug('Əli Həsənov');           // 'eli-hesenov'
slug('Tom & Jerry');           // 'tom-and-jerry'
```

## Supported Languages

| Language | Characters | Example |
|---|---|---|
| Turkish | ç, ğ, ı, İ, ö, ş, ü | `Çığırtkan` → `cigirtkan` |
| Azerbaijani | ə, Ə | `Əli` → `eli` |
| Russian (Cyrillic) | а-я, А-Я | `Привет` → `privet` |
| German | ä, ö, ü, ß | `Straße` → `strasse` |
| French | à, â, é, è, ê, ë, î, ô, ù, û | `café` → `cafe` |
| Spanish | ñ, á, é, í, ó, ú | `señor` → `senor` |
| Polish | ą, ć, ę, ł, ń, ź, ż | `łódź` → `lodz` |
| Czech/Slovak | ď, ě, ň, ř, ť, ů, ž | `řeka` → `reka` |

## API

### `slug(input: string, options?: SlugOptions): string`

Converts a string into a URL-safe slug.

### Options

| Option | Type | Default | Description |
|---|---|---|---|
| `separator` | `string` | `'-'` | Character used to replace spaces |
| `fallback` | `string` | `''` | Value returned when the result is empty |
| `lowercase` | `boolean` | `true` | Convert output to lowercase |
| `maxLength` | `number` | `undefined` | Truncate slug to this length (trims trailing separator) |

### Examples

```typescript
// Custom separator
slug('file_name.txt', { separator: '_' });  // 'file_name_txt'

// Fallback for empty input
slug('', { fallback: 'untitled' });  // 'untitled'

// Preserve case
slug('Hello World', { lowercase: false });  // 'Hello-World'

// Max length
slug('A very long title', { maxLength: 10 });  // 'a-very'
```

## License

MIT - Scuton Technology