open-index/open-npm huggingface dataset:
npm package: @kelcon/homebridge-zwave-direct
Description: Homebridge plugin that talks directly to a OpenZWave USB stick
Author: Mario Smit
Latest version: 1.0.0

# Homebridge ZWave Direct

Homebridge plugin that communicates directly with ZWave devices via OpenZWave librariesplugin that communicates directly with ZWave devices via OpenZWave libraries

## Features
Currently support the following devices:
- BINARY_SENSOR, like motion sensors
- BINARY_SWITCH, like mains switches
- MULTI_LEVEL_SENSORS, for temperature, humidity, luminosity, power meters
- SIRENs, shown as a switch

It also allow to start inclusion via a virtual Switch Accessory called Inclusion. This will instruct the ZWave stick to start inclusion of a new ZWave device. Typically such a device needs to be put in Inclusion mode (3 rapid clicks on a button)

## Installation

1. Install Homebridge using: `npm install -g homebridge`
2. Install this plugin using: `npm install -g git+https://git@github.com/S0urceror/homebridge-zwave-direct.git`
3. Download and install OpenZWave binaries: ` `
4. Add the user running homebridge to the dialout group: `sudo usermod -a -G dialout $HOMEBRIDGE_USER`
5. Update your configuration file. See the sample below.

## Sample Configuration

Please specify to which serial device your USB stick is connected.

The config file allows to set emptyhomebridgecache to true, to flush all ZWave devices from Homekit, and redetect them. Helpful while debugging.

New in this version is the ability to specify hinted devices. In a ZWave network battery operated devices are most of time sleeping and not continuously advertising their presence and capabilities. This way they would never appear in HomeKit. This way we can specify what type of device it is and which capabilities it has. The Zwave bridge will then map the right HomeKit types to the ZWave command-classes. 

```
"platforms": [
    {
      "platform": "zwave-direct",
      "serial": "/dev/cu.usbmodem1421",
      "emptyhomebridgecache": false,
      "hinteddevices": [{
        "nodeid": 4,
        "type": "Binary Sensor",
        "subtypes" : "temperature,luminance,batterylevel",
        "name": "Kitchen Sensor"
      },{
        "nodeid": 10,
        "type": "Binary Sensor",
        "subtypes" : "temperature,luminance,batterylevel",
        "name": "Livingroom Sensor 1"
      }
    }
]
```

## Credits
The guys over at OpenZWave for creating the libs, nodejs client and typescript definitions.
Homespun and SphtKr for additional communitytypes, this enables me to emulate a ZWave metering outlet as an Elgato Eve Energy. 
The Z-Wave standard, now becoming more open, is still an easy and rock solid communication protocol.
npm package: @kelda/install
Description: This repo contains a Node.js package for easily installing [Kelda](http://kelda.io) using npm.
Latest version: 0.13.1

This repo contains a Node.js package for easily installing
[Kelda](http://kelda.io) using npm.

To pull the compiled binaries off GitHub, and install them:
```
$ npm install -g @kelda/install
```
Note that the `-g` flag is necessary to install the binaries globally (i.e. so
that `kelda` can be invoked from anywhere).

If installing as root, the `--unsafe-perm` flag is required:
```console
$ sudo npm install -g @kelda/install --unsafe-perm
```
npm package: @kele23/gantt
Description: A simple, modern, interactive gantt library for the web based on Frappe Gantt
Author: Michele Scala
Latest version: 0.1.20

# Gantt

A modern gantt widget based on [Frappe Gant](https://github.com/frappe/gantt)

### Why a new Gantt widget?
I was looking for a typescript first and good looking gantt widget for a project. After some search I tried Frappe Gantt that I found very good looking and simple to use.

The problem is that Frappe Gantt was not written in typescript, so types are not always aligned to the real. Moreover it was missing some functionality that I need ( ex: groups ) and have some bugs.

So I completely rewrite all the gantt, removing some "editing" functionality ( that I plan to reintroduce ), changing editing and other things to have a very simple and functional Gantt widget.


### How to use?
```javascript
const tasks: Task[] = [...]
const groups: TaskGroup[] = [...]
const options: Options = {};

// create the gantt using options, tasks and groups
const gantt = new Gantt('#id', tasks, options, groups);

// set view mode to "week" and center the gantt to today
// each time view mode is changed, gantt is rendered
gantt.changeViewMode('week', "today");
```
npm package: @kele23/gibberish
Description: Detects if a string appears to be gibberish, using markov-chaining
Author: Michele Scala
Latest version: 1.2.1

# Gibberish Detector

This utility is used to identify if a string of text contains gibberish, using a relatively simple implementation of Machine Learning and Markov Chaining. The utility is trained with a large sample of legitimate sentences with which it builds a model to determine the probability that any two characters would be found adjacently.

# Usage

Usage with CLI and providing text as parameter
```bash
gibberish test --text "My text" --model en # prebuild model
gibberish test --text "My text" --model model.json # custom model
```

Usage with CLI and providing text in a file
```bash
gibberish test --file text.txt --model en # prebuild model
gibberish test --file text.txt --model model.json # custom model
```

Usage as Javascript library
```javascript
import { testGibberish } from '@kele23/gibberish';
import { MODELS } from '@kele23/gibberish/prebuild';
testGibberish(text, MODELS['en']);
```

# Training

This package is shipped with default models in English and Italian languages you can find them in prebuild section of the project. If necessary, a new model can be generated. As an example, if someone wishes to use this with another language, it might be prudent to generate a model based off of this language.

For best results the training text used should be decently long (at least few megabytes) with diverse and legitimate words. It is not recommended that it be trained using literature from the science fiction and fantasy genres because those selections often contain unusual word formations.

To create a new learning model, you must provide it with the aforementioned large sample of text to build the learning matrix, a sample of short lines of sentences that make sense, and a sample of lines made up of gibberish. It uses the last two data sets to form a threshold between gibberish and non-gibberish text.

You can use the cli tool provided to create a new Model.

```bash
gibberish train --train data/train.txt --goodsm data/good_sm.txt --badsm data/bad_sm.txt --target model.json              
```


# Attributions
 * rrenaud originally created a projected similar to this in python, called [Gibberish-Detector](https://github.com/rrenaud/Gibberish-Detector).
 * Alpha4615 originally ported the library to javascript [gibberish-detection](https://github.com/Alpha4615/gibberish-detection)
npm package: @kelechi_i/buddy-component-library
Description: Reusable React component library for OaaS (Onboarding-as-a-Service)
Latest version: 0.1.1

# @kelechi_i/buddy-component-library

Reusable React component library for the OaaS app.

## Install

```bash
pnpm add @kelechi_i/buddy-component-library
```

Peer deps required in host app:
- react >=18
- react-dom >=18

## Build

```bash
pnpm build
```

## Storybook

```bash
pnpm storybook
```

## Test

```bash
pnpm test
```

## Usage

```tsx
import { Header, Description, TextInput, Checklist, Media } from '@kelechi_i/buddy-component-library';

export default function Example() {
	return (
		<div>
			<Header title="Welcome" subtitle="Start here" align="center" />
			<Description text="A simple description" />
			<TextInput label="Name" placeholder="Enter your name" />
			<Checklist items={[{ id: '1', label: 'Read handbook' }]} />
			<Media type="image" src="https://via.placeholder.com/400x200" />
		</div>
	);
}
```
npm package: @keleran/exon
Description: Exchange Online PowerShell interface module
Author: Dmitry Chekanov
Latest version: 1.0.1

# Exchange Online PowerShell interface

This module makes it easier for Node.js applications to communicate with Exchange Online via PowerShell.

Tested in Kubuntu 20.10, Node.js 14.

## Setup

The server must have PowerShell and Exchange Online PowerShell V2 module version 2.0.4 or newer installed.

The patched [OMI](https://github.com/jborean93/omi) must be installed as well.

You'd need to create an app in Azure AD with a PFX certificate generated and uploaded.

```shell
npm i @keleran/exon
```

## Usage

```javascript
const Exon = require('@keleran/exon');

const exon = new Exon({
  // mandatory
  connection: {
    appId: '*',
    // path to the .pfx file
    certificateFilePath: '*',
    // account domain 
    organization: '*.onmicrosoft.com'
  },
  // optional, defaults to the shown values
  timeouts: {
    spawn: 5000,
    exec: 180000
  },
  // optional - where to write log entries to 
  logFilePath: '*'
});

// resolved with stdout content
// rejected with stderr content
// there's no queue, wait for it to finish before sending a new command or it will be rejected instantly
// the first run will take extra time to download cmdlets from the remote server
const result = await exon.exec('CMDLET_NAME', {'CMDLET_PARAM_NAME': 'CMDLET_PARAM_VALUE'});

// disconnect from Exchange and kill PS process
// it will respawn and reconnect automatically on the next .exec()
// useful for graceful shutdown or if you believe it could help with some PS-related issue 
await exon.reset();
```
npm package: @keleran/routing
Description: Routing utilities for Node.js projects
Author: Dmitry Chekanov
Latest version: 4.0.0

# @keleran/routing

Utilities to simplify request routing in Node.js projects.  
Use ESM, require Node.js 16+.

![GitHub Workflow Status](https://img.shields.io/github/workflow/status/dchekanov/routing/Test)

## Installation

```bash
$ npm i @keleran/routing
```

```javascript
import {discover, mount} from '@keleran/routing';
```

## `discover`

Returns a flat list of route handlers found in the specified directory. 
If you don't need to work with the list before mounting, use `mount` directly - it returns the same data.

```javascript
// [{route: String, method: String, source: Object, pipeline: Array}, ...]
const handlers = await discover({dir: 'routes'});
```

## `mount`

Reads a file tree and mounts request handlers to the specified Express app.

Request handler is a file named as "HTTP_METHOD.js" (get.js, post.js, etc.) that exports an object
with the following properties:

1. "rateLimit" (optional) - a string or an object that defines rate limiting options 
for the [rate-limiter-flexible](https://github.com/animir/node-rate-limiter-flexible) library.  
The string is parsed with the [ms](https://github.com/vercel/ms) library, 
"1s" means "allow 1 request per second from this IP".  
The object is passed to rate-limiter-flexible as is. HTTP 429 will be thrown upon exceeding the limit.
2. "authorize" (optional) - an authorization function that MUST return true for request to be processed.
Otherwise it throws HTTP 403 using the [http-errors](https://github.com/jshttp/http-errors) library. 
Supplied with the "req" and "res" arguments. Can be async.
3. "middleware" (optional) - a function or an array of functions that are regular middleware 
with the "req", "res", and "next" arguments supplied.
4. "handle" - the main function that handles the request. Supplied with the "req" and "res" arguments. Can be async.

The order of execution matches the order listed above.

### Example

The following tree:

```
routes
├── =
│   └── get.js
└── route
    ├── get.js
    └── =param-name
        └── get.js
``` 

With the call:

```javascript
await mount({dir: 'routes', app, route: '/test'});
```
 
Will be mounted like this (notice the order and param/wildcard substitution):
 
```javascript
app.get('/test/route', /* handler defined in routes/route/get.js */);
app.get('/test/route/:paramName', /* handler defined in routes/route/=param-name/get.js */);
app.get('/test/*', /* handler defined in routes/=/get.js */);
```
npm package: @keleran/toolkit
Description: Building blocks for Node.js web applications
Author: Dmitry Chekanov
Latest version: 1.0.1

This package is a merged, refactored, and extended continuation of [@keleran/orm](https://www.npmjs.com/package/@keleran/orm) and [@keleran/routing](https://www.npmjs.com/package/@keleran/routing).

It provides a few essential building blocks for Node.js web applications:

- [CodedError](./lib/coded-error.js) - an `Error` with a mandatory code and optional metadata.
- [HttpError](./lib/http-error.js) - a `CodedError` with a mandatory HTTP status code.
- [Db](./lib/db.js) - query a PostgreSQL database using MongoDB-inspired syntax or raw SQL.
- [Model](./lib/model.js) - define business logic entities as classes, persist instances with `Db`.
- [ModelLinker](./lib/model-linker.js) - simplify getting referenced model instances.
- [RequestHandler](./lib/request-handler.js) - define Express request handler.
- [RouterCodegen](./lib/router-codegen.js) - organize routing using a file system directory tree.

Usage guidelines and examples can be found in the source code and test files.

While you're welcome to use this code in your own projects, the primary goal of publishing this package is
to make it easier for the author to maintain his closed-source applications. This means that the code will remain highly opinionated, simplistic, and prone to sudden breaking changes.
npm package: @keleshteri/ai-rag
Description: RAG (Retrieval-Augmented Generation) library for NestJS with vector database integration
Author: MMSK Keleshteri
Latest version: 0.0.10

# @keleshteri/ai-rag

Retrieval-Augmented Generation (RAG) package for NestJS applications with vector database integration.

## Features

- **Document Processing**: Process and chunk documents with customizable strategies
- **Embedding Generation**: Create vector embeddings using various providers (OpenAI, Ollama, etc.)
- **Vector Storage**: Store and query vector embeddings with different vector databases
- **Semantic Search**: Find relevant documents based on semantic similarity
- **Response Generation**: Generate responses using the retrieved context

## Installation

```bash
npm install @keleshteri/ai-rag
```

## Quick Start

```typescript
import { Module } from '@nestjs/common';
import { RagModule } from '@keleshteri/ai-rag';

@Module({
  imports: [
    RagModule.forRoot({
      config: {
        vectorStore: {
          type: 'memory', // For development
          connection: {},
        },
        embedding: {
          type: 'openai',
          options: {
            apiKey: process.env.OPENAI_API_KEY,
          }
        },
        documentProcessing: {
          chunkingStrategy: 'paragraph',
          chunkSize: 1000,
          chunkOverlap: 200,
        },
      },
    }),
  ],
})
export class AppModule {}
```

## Usage

### Adding Documents

```typescript
import { Injectable } from '@nestjs/common';
import { RagService } from '@keleshteri/ai-rag';

@Injectable()
export class DocumentService {
  constructor(private readonly ragService: RagService) {}

  async addDocument(content: string, metadata: Record<string, any>) {
    const documentId = await this.ragService.addDocument({
      content,
      metadata,
    });
    
    return documentId;
  }
}
```

### Generating Responses

```typescript
import { Injectable } from '@nestjs/common';
import { RagService } from '@keleshteri/ai-rag';

@Injectable()
export class QueryService {
  constructor(private readonly ragService: RagService) {}

  async generateResponse(query: string) {
    const result = await this.ragService.generateResponse(query, {
      maxDocuments: 4,
      includeMetadata: true,
    });
    
    return result;
  }
}
```

## Supported Vector Databases

- Memory (for development and testing)
- Postgres (with pgvector extension)
- Qdrant
- Pinecone
- and more...

## Supported Embedding Providers

- OpenAI
- Ollama
- TypeScript (for testing)

## License

MIT
npm package: @keleshteri/devops-bot
Description: A DevOps bot for AI-powered code reviews, GitLab automation, Slack notifications, and ClickUp tracking.
Author: MMSK Keleshteri
Latest version: 1.0.72

# DevOps Bot for NestJS

A comprehensive DevOps automation solution that integrates GitLab, Slack, ClickUp, and AI-powered code reviews.

## Installation

```bash
npm install @keleshteri/devops-bot
```

## Important Setup Requirements

Before using this package, you must configure the EventEmitter in your root module:

```typescript
import { Module } from '@nestjs/common';
import { EventEmitterModule } from '@nestjs/event-emitter';
import { DevOpsBotModule } from '@keleshteri/devops-bot';

@Module({
  imports: [
    // Required: Configure EventEmitter before using DevOpsBot
    EventEmitterModule.forRoot({
      // Your event emitter configuration
    }),
    
    DevOpsBotModule.forRoot({
      gitlab: {
        token: 'your-gitlab-token',
        secret: 'your-gitlab-secret',
      },
      // ... other configurations
    }),
  ],
})
export class AppModule {}
```

## Features

- GitLab Integration
- Slack Notifications
- ClickUp Task Management
- AI-Powered Code Reviews
- Azure DevOps Integration
- Sprint Planning
- Storage Solutions
- Caching Support

## Quick Start

```typescript
import { DevOpsBotModule } from '@keleshteri/devops-bot';

@Module({
  imports: [
    DevOpsBotModule.forRoot({
      gitlab: {
        token: 'your-gitlab-token',
        secret: 'your-gitlab-secret',
      },
      // ... other configurations
    }),
  ],
})
export class AppModule {}
```

## Configuration Options

See [Configuration Guide](./docs/configuration.md) for detailed options.

## API Reference

See [API Documentation](./docs/api.md) for detailed API usage.

## Contributing

Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @kelianb/web-mix-engine
Description: Model and utilities for mixing music using the Web Audio API.
Author: Kelian Baert
Latest version: 0.3.5

# web-mix-engine

Model and utilities for mixing music using the Web Audio API.

## Project setup

```
npm install
```

## Testing

```
npm run test
```

## Memos

### Bump version

Run `npm version minor` or `npm version patch` for example. This takes care of linting, bumping the version in package.json, creating a new commit & tag and pushing upstream to git.

### Publish new version to npmjs

```
npm publish
```