open-index/open-npm huggingface dataset:
npm package: @quigleybits/claude-skills
Description: Custom Claude Code skills: recon, and more
Author: quigleyBits
Latest version: 0.1.0

# @quigleybits/claude-skills

Custom skills (slash commands) for [Claude Code](https://claude.ai/claude-code).

## Install

```bash
npm install -g @quigleybits/claude-skills
```

Skills are automatically linked into `~/.claude/skills/` on install and cleanly removed on uninstall.

## Skills

### /recon

Full-spectrum project reconnaissance. Scans all documentation, cross-references claims against the actual codebase, audits doc health, and presents prioritized next steps.

**Use when:** Starting work on a project, resuming after a break, onboarding to a new codebase, or needing to understand current project state.

**What it does:**
1. Discovers all docs (markdown, rst, adoc) + recent git activity
2. Scans and reality-checks claims against the codebase
3. Synthesizes prioritized next steps (Critical / Important / Normal / Low)
4. Identifies missing documentation categories and offers to create them
5. Audits doc health with user-gated fix options

## Uninstall

```bash
npm uninstall -g @quigleybits/claude-skills
```

## License

MIT
npm package: @quik-fe/flick
Description: nodejs cli utils like fire(python)
Author: lenml
Latest version: 1.0.1

# flick

nodejs cli utils like fire(python)

## features

- safety typing
- easy to define

# usage

install

```
pnpm add @quik-fe/flick
```

```ts
import { flick } from "@quik-fe/flick";
import { z } from "zod";

const argsDef = {
  greet: z
    .object({
      name: z.string().describe("Name to greet"),
      times: z.number().optional().default(1).describe("Number of repetitions"),
      upcase: z.boolean().optional().describe("Uppercase the name"),
    })
    .describe("Greet a person multiple times"),
};

flick(argsDef)
  .describe("Hello world from flick")
  .handler({
    greet: ({ name, times, upcase }) => {
      let text = `👋 Hello, ${name}`;
      if (upcase) text = text.toUpperCase();
      for (let i = 0; i < times; i++) {
        console.log(text);
      }
    },
  })
  .parse();
```

```bash
$ npx tsx ./demo.ts -h
Usage: demo [options] [command]

Hello world from flick

Options:
  -h, --help       display help for command

Commands:
  greet [options]  Greet a person multiple times
  help [command]   display help for command
```

```bash
$ npx tsx ./demo.ts greet -h
Usage: demo greet [options]

Greet a person multiple times

Options:
  --name <name>    Name to greet
  --times <times>  Number of repetitions (default: 1)
  --upcase         Uppercase the name
  -h, --help       display help for command
```

```bash
$ npx tsx ./demo.ts greet --name lenml --no-upcase --times=3
👋 Hello, lenml
👋 Hello, lenml
👋 Hello, lenml
```

> If you define a boolean-type parameter, you can also use a hidden `--no-<key>` parameter to indicate negation.

# LICENSE

MIT
npm package: @quik-fe/mapred
Description: A lightweight multi-threaded MapReduce implementation based on Node.js Worker Threads.
Author: zhzluke96
Latest version: 1.1.2

# `@quik-fe/mapred`

A lightweight multi-threaded MapReduce implementation based on Node.js Worker Threads.

## Features

- Auto utilize multi-cores for parallel computing
- Support async mapper/reducer functions
- Built-in progress tracking and error handling 
- Type-safe (TypeScript)
- Zero dependencies

## Install

```bash
npm install @quik-fe/mapred
```

## Constructor Options

```typescript
new FuncWorker<T,M,R>({
  // Required: Map function that processes each input item
  mapper: (data: T) => M | Promise<M>,
  // Required: Reduce function that combines mapped results
  reducer: (batch: M[], progress: ProgressFn) => R | Promise<R>,
});

new ScriptWorker("./your_worker_script.js|ts");

new MapReducer({
  // Required: threads worker define.
  worker: MapRedWorker,
  
  // Optional: Group results by key before reducing (default: () => "task")
  keyFn?: (data: T) => string | number,
  
  // Optional: Sort mapped results before reducing (default: basic type sorting)
  sortFn?: (a: M, b: M) => number,
  
  // Optional: Number of worker threads (default: CPU cores)
  poll_size?: number
})
```

## Quick Start

```typescript
import { MapReducer } from '@quik-fe/mapred'

// 1. Define mapper and reducer
const map = (x: number) => x * 2
const reduce = (nums: number[]) => nums.reduce((a, b) => a + b)

// 2. Create instance
const worker = new FuncWorker({ map, reduce })
const mr = new MapReducer({ worker })

// 3. Run computation
const result = await mr.mapReduce([1,2,3,4,5])
```

## Example: Calculate π

```typescript
const worker = new FuncWorker({
  // Map: Generate random points and check if they are inside unit circle
  mapper: async (points: number) => {
    let inside = 0;
    for(let i = 0; i < points; i++) {
      const x = Math.random() * 2 - 1;
      const y = Math.random() * 2 - 1;
      if(x * x + y * y <= 1) inside++;
    }
    return { inside, total: points };
  },

  // Reduce: Calculate π from all results
  reducer: async (results) => {
    const total = results.reduce((a, b) => a + b.inside, 0);
    const points = results.reduce((a, b) => a + b.total, 0);
    return 4 * (total / points);
  }
});
const mapReducer = new MapReducer({worker});

const result = await mapReducer.mapReduce(new Array(1000).fill(10000));
console.log('π ≈', result[0].result);
```

## Example: Script Worker
worker.ts
```ts
import {define} from "@quik-fe/mapred";

define({
  map: (x: number) => x * 2,
  reduce: (nums: number[]) => nums.reduce((a, b) => a + b)
});
```
main.ts
```ts
import { MapReducer, ScriptWorker } from '@quik-fe/mapred';
const worker = new ScriptWorker("./worker.ts");
const mr = new MapReducer({ worker })
const result = await mr.mapReduce([1,2,3,4,5])
```


## License

MIT
npm package: @quik-fe/node-nvidia-smi
Description: A Node.js wrapper for NVIDIA SMI to monitor GPU stats.
Author: zhzluke96
Latest version: 1.0.2

# @quik-fe/node-nvidia-smi

Node.js wrapper for the `nvidia-smi` (NVIDIA System Management Interface) command line utility. This package provides a simple way to monitor and query NVIDIA GPU information.

## Prerequisites

- NVIDIA drivers must be installed
- `nvidia-smi` command line tool must be available in your system PATH

## Installation

```bash
npm install @quik-fe/node-nvidia-smi
```

## Usage

```typescript
import { NvidiaSMI } from "@quik-fe/node-nvidia-smi";

// Check if nvidia-smi exists
const exists = await NvidiaSMI.exist();

// Get GPU information
const gpuInfo = await NvidiaSMI.Utils.getGPUInfo();

// Get memory usage
const memoryUsage = await NvidiaSMI.Utils.getMemoryUsage();

// Get driver version
const driverVersion = await NvidiaSMI.Utils.getDriverVersion();
```

## API

### Base Functions

- `NvidiaSMI.exist()`: Check if nvidia-smi is available
- `NvidiaSMI.get_details()`: Get raw XML data from nvidia-smi

### Utility Functions

- `getDriverVersion()`: Get NVIDIA driver version
- `getCudaVersion()`: Get CUDA version
- `getAttachedGPUs()`: Get number of attached GPUs
- `getGPUInfo(uuid?)`: Get GPU information for specific UUID or first GPU
- `getMemoryUsage(uuid?)`: Get memory usage statistics
- `getTemperature(uuid?)`: Get GPU temperature
- `getUtilization(uuid?)`: Get GPU utilization
- `getECCErrors(uuid?)`: Get ECC error information
- `getProcesses(uuid?)`: Get running process information
- `getFanSpeed(uuid?)`: Get fan speed
- `getPowerReadings(uuid?)`: Get power consumption information
- `getClocks(uuid?)`: Get clock speeds
- `getComputeMode(uuid?)`: Get compute mode
- `getPerformanceState(uuid?)`: Get performance state

All utility functions are accessible via `NvidiaSMI.Utils` namespace.


## License

MIT

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
npm package: @quik-fe/stand
Description: zustand-like
Author: zhzluke96
Latest version: 1.1.10

# stand

zustand-like

# usage

```tsx
import { bindReact } from "@quik-fe/stand";
import * as React from "react";

const create = bindReact(React);

// middleware
const logger = (set, get) => {
  return [
    (x) => {
      set(x);
      console.log(`set: `, x);
    },
    () => {
      const state = get();
      console.log(`get: `, state);
      return state;
    },
  ];
};

const useAppStore = create<{
  counter: {
    count1: number;
  };
  inc: () => void;
  dec: () => void;
}>(
  (set, get) => ({
    counter: {
      count1: 1,
    },
    inc: () =>
      // immer style is working
      set((state) => {
        state.counter.count1 += 1;
        return state;
      }),
    dec: () =>
      // update style is working
      set({ counter: { count1: get().counter.count1 - 1 } }),
    mul: (k) =>
      // reducer setter is working
      set(state => ({
        counter: : {
          count1: state.counter.count1 * k
        }
      }))
  }),
  logger,
  /** More middleware can be placed here  */
);

const App = () => {
  // no selector (auto-selector) is working
  const {
    counter: { count1 },
  } = useAppStore();
  return <button onClick={useAppStore.get().inc}>count: {count1}</button>;
};
```

# license

MIT
npm package: @quik-link/core
Description: A package to template lorem ipsum.
Author: Elijah Cobb
Latest version: 0.1.7

# ***
A package to template lorem ipsum.

## Import
## Examples

## Documentation
Everything is completely documented. You can view the
[declaration files](https://github.com/elijahjcobb/request/***/master/dts) or even the
[source code](https://github.com/elijahjcobb/***/tree/master/ts) on GitHub.

## Bugs
If you find any bugs please [create an issue on GitHub](https://github.com/elijahjcobb/***/issues) or if you are old
fashioned email me at [elijah@elijahcobb.com](mailto:elijah@elijahcobb.com).
npm package: @quikcess/bet-api-types
Description: Typings for Quikcess Bet API
Author: Eydrenn Araujo
Latest version: 0.0.9

# bet-api-types

Simple type definitions for the **Quikcess Bet API**.

[![GitHub](https://img.shields.io/github/license/quikcess/bet-api-types)](https://github.com/quikcess/bet-api-types/blob/main/LICENSE)
[![npm](https://img.shields.io/npm/v/bet-api-types?color=crimson&logo=npm)](https://www.npmjs.com/package/@quikcess/bet-api-types)

## Installation

```bash
npm install @quikcess/bet-api-types
// or
yarn add @quikcess/bet-api-types
// or
pnpm add @quikcess/bet-api-types
```

## Getting Started

Using these type definitions is simple. You just need to specify the appropriate version of the API by appending `/v*` to the import path, where `*` represents your desired API version. Here are some usage examples:

```ts
// Importing the API definitions for version 1
import { APIBet, BetStatus } from 'bet-api-types/v1';
```

You can also import only the specific parts of the module that you need. Here are some examples:

```ts
// Importing specific types for bets and scams in version 1
import { APIBet, APIScam } from 'bet-api-types/v1';
```

> _**Note:** The `v*` exports (`bet-api-types/v*`) include the relevant version of types for `bet`, `blacklist`, `scam`, `credential`, and `status`, along with utilities and helpers._

## Project Structure

he exported types for each API version are organized into two main categories:

Types with an `API` prefix represent payloads you may receive from the REST API.
Types with a `REST` prefix represent data that is sent to and received from the REST API.
For endpoint options in the `REST` category, they follow a specific structure: `REST<HTTP Method><Action><Type>`, where the type indicates the expected return data. For example, `RESTPostAPIBetCreateBody` or `RESTGetAPICredentialResponse`.

If a type name ends with Response, it represents the expected result when calling its corresponding route.
In this structure, the `REST` types are used to define the data sent in requests (e.g., creating a bet ), while the `API` types represent the data received in responses from the API (e.g., the details of a bet). This makes the distinction clear between what is transmitted to the API and what is returned after a request is made.
npm package: @quikcess/sdk-bet
Description: Official Quikcess Bet SDK for NodeJS
Author: Eydrenn Araujo
Latest version: 0.0.9

<h1 align="center">@quikcess/sdk-bet</h1>
<p align="center">Software development kit for Quikcess bet bots.</p>

<div align="center">
  <div style="width: fit-content; display: flex; align-items: flex-start; gap: 4px;">
    <img alt="NPM License" src="https://img.shields.io/npm/l/@quikcess/sdk-bet">
    <img alt="NPM Downloads" src="https://img.shields.io/npm/dw/@quikcess/sdk-bet">
    <a href="https://npmjs.com/package/@quikcess/sdk-bet">
      <img alt="NPM Version" src="https://img.shields.io/npm/v/@quikcess/sdk-bet">
    </a>
  </div>
</div>

## Installation

```bash
npm install @quikcess/sdk-bet
// or
yarn add @quikcess/sdk-bet
// or
pnpm add @quikcess/sdk-bet
```

## Documentation

Visit our [official API documentation](https://docs.quikcess.com/sdk-bet-reference/) for more information about this service.

## Getting Started

- _Login and get your API Key at [https://discord.gg/quikcess](https://discord.gg/quikcess)._

```ts
import { Betting } from "@quikcess/sdk-bet";
// CommonJS => const { Betting } = require("@quikcess/sdk-bet");

const client = new Betting("Your API Key");
```
npm package: @quild/core
Description: Quild is a query language for building JSON-LD documents from RDF-style data sources, such as JSON-LD, RDF stores, or m-ld.
Author: Petra Jaros
Latest version: 0.1.0

# 🦔 Quild — Queries in Linked Data: Core Query Behavior

This package is the core library for Quild. See the [repo README](https://github.com/m-ld/quild/?tab=readme-ov-file#quildcore) for usage information.
npm package: @quild/observable
Description: Quild queries as RxJS observables.
Author: Petra Jaros
Latest version: 0.1.0

# 🦔 Quild — Queries in Linked Data: Observable Interface

This package is the Observable interface for Quild. See the [repo README](https://github.com/m-ld/quild/?tab=readme-ov-file#quildobservable) for usage information.
npm package: @quild/react
Description: Quild queries as a React hook.
Author: Petra Jaros
Latest version: 0.1.0

# 🦔 Quild — Queries in Linked Data: React Hook Interface

This package is the React hook interface for Quild. See the [repo README](https://github.com/m-ld/quild/?tab=readme-ov-file#quildreact) for usage information.