open-index/open-npm huggingface dataset:
npm package: @felipehonorio/card
Description: A personal card for Felipe Honório
Author: Felipe Honório
Latest version: 4.0.1

# Felipe Honorio's Card

Desenvolvedor Full Stask na Wevo

[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/americoneto1/card/blob/master/LICENSE) 
[![npm version](https://badge.fury.io/js/%40felipehonorio%2Fcard.svg)](https://www.npmjs.com/package/@felipehonorio/card)

## Use

Via npx:

```bash
npx @felipehonorio/card
```

## Credits

Forked from Tierney Cyren's https://github.com/bnb/bitandbang

Badges from <https://badge.fury.io/for/js>
npm package: @felipejesus/openloop
Description: Ralph Loop plugin for OpenCode with automatic continuation until completion.
Latest version: 0.1.1

# @felipejesus/openloop

Ralph Loop for [OpenCode](https://opencode.ai): start a task once, then let the plugin keep nudging the session forward until it truthfully emits `<promise>DONE</promise>`.

## What it does

- adds `/ralph-loop` to start an auto-continuation loop
- adds `/cancel-ralph` to stop an active loop
- adds `/ralph-help` for a quick reference
- stores loop state in `.opencode/ralph-loop.local.md`
- watches for `session.idle`, checks the last assistant reply, and continues the session if the task is not done yet

## Install

Add the plugin name to your OpenCode config after publishing or installing it as a dependency:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@felipejesus/openloop"]
}
```

On first load, the plugin copies its commands and skills into your OpenCode config directory so the slash commands are available globally.

For this repository specifically, a project-local loader lives at `.opencode/plugins/ralph-loop.ts`, so opening this repo in OpenCode will also load the plugin directly from source.

## Commands

```text
/ralph-loop Build a REST API with authentication
/cancel-ralph
/ralph-help
```

## How it works

1. `/ralph-loop` writes `.opencode/ralph-loop.local.md`
2. the plugin binds that loop to the current OpenCode session
3. when the session goes idle, the plugin checks the latest assistant text for `<promise>DONE</promise>`
4. if the promise is missing and the iteration cap is not reached, the plugin sends a continuation prompt back into the same session
5. the loop stops when the promise appears, the loop is cancelled, or `maxIterations` is reached

## Development

```bash
npm install
npm run release:check
```

## Release pipeline

GitHub Actions is configured with:

- `/.github/workflows/ci.yml` to run type-checking and package validation on pushes and pull requests
- `/.github/workflows/release.yml` to publish to npm and create a GitHub Release when a `v*` tag is pushed

Release migration plan:

1. Publish the first version of `@felipejesus/openloop` with the existing `NPM_TOKEN`
2. Open the `@felipejesus/openloop` package settings on npm
3. Add a GitHub Actions trusted publisher
4. Use `felipepiresdejesus` as the owner, `openloop` as the repository, and `release.yml` as the workflow filename
5. After trusted publishing is working, delete the old `NPM_TOKEN` GitHub secret

The release workflow is compatible with both stages: npm will use the token for the first publish, then switch to GitHub OIDC once trusted publishing is configured.

To cut a release:

```bash
git tag v0.1.0
git push origin v0.1.0
```

## Repo layout

```text
src/index.ts              Main plugin implementation
commands/                 Slash commands installed into OpenCode
skills/                   Lazy-loaded skills installed into OpenCode
```
npm package: @felipemantilla01/commit
Description: A tool to generate commit messages using AI.
Author: Felipe Mantilla
Latest version: 1.0.16


# @felipemantilla01/commit

## Description

`@felipemantilla01/commit` is a tool that facilitates the generation of commit messages using AI to analyze file changes and generate concise and well-structured commit messages. It is designed for developers who want to improve the quality of their commit messages and streamline the commit process.

![Demo](https://github.com/Felipemantilla01/commit/blob/main/assets/demo.gif)

## Installation

To install the package globally, use the following command:

```bash
npm install -g @felipemantilla01/commit
```

## Usage

### Initial Setup

Before using the tool, you need to perform an initial setup to specify the AI provider and the API token:

```bash
commit --setup
```

This command will start an interactive prompt asking for the following information:

1. **AI Provider**: Currently, only Anthropic is supported.
2. **API Token**: Enter your API token for the selected AI provider.
3. **Commit Types**: Select the commit types you want to use or add custom types.

The configuration will be saved in a file named `commit-config.json` in the current directory.

### Generate Commit Messages

To generate a commit message based on the staged files and the current diff, simply run:

```bash
commit
```

The command will perform the following actions:

1. Read the staged files and get the diff.
2. Read the content of the staged files.
3. Generate a commit message using AI.
4. Display the generated commit message and ask for confirmation before committing.

### Sign Commits with GPG

If you want to sign your commits with GPG, you can use the `-S` or `--gpg-sign` option:

```bash
commit -S
```

## Command Line Options

- `--setup`: Run the initial setup to specify the AI provider, API token, and commit types.
- `-S`, `--gpg-sign`: Sign commits with GPG.

## Example

1. Run the initial setup:

   ```bash
   commit --setup
   ```

2. Generate a commit message and commit:

   ```bash
   commit
   ```

3. Generate a commit message and sign the commit with GPG:

   ```bash
   commit -S
   ```

## Contributing

Contributions are welcome. If you find an issue or have a suggestion, please open an issue in the GitHub repository.

## License

This project is licensed under the MIT License.

---

Thank you for using `@felipemantilla01/commit`!
npm package: @felipemocruha/fastify-route-timeout
Description: A Fastify plugin to automatically set timeouts for routes. If a route takes longer than its specified timeout, a custom response will be sent.
Author: Felipe Alcantara
Latest version: 1.1.2

# fastify-route-timeout

A Fastify plugin to automatically set timeouts for routes. If a route takes longer than its specified timeout, a custom response will be sent.

## Features

- Set a default timeout for all routes.
- Specify custom timeouts for specific routes and methods.
- Customize the timeout response payload.

## Installation

```bash
npm install --save @felipemocruha/fastify-route-timeout
```

## Usage

### Basic Usage

```javascript
import fastify from "fastify";
import { RequestTimeoutPlugin } from "@felipemocruha/fastify-route-timeout";

const server = fastify();

server.register(RequestTimeoutPlugin, {
  defaultTimeoutMillis: 5000,
});

server.listen(3000);
```

With the above setup, all routes will have a default timeout of 5 seconds.

### Custom Route Timeouts

You can specify custom timeouts for specific routes and methods:

```javascript
server.register(RequestTimeoutPlugin, {
  defaultTimeoutMillis: 5000,
  routes: {
    "/specific-route": {
      GET: 10000, // 10 seconds for this specific route and method
      POST: 2000, // 2 seconds for this specific route and method
    },
  },
});
```

### Custom Timeout Response

You can **optionally** customize the response payload sent when a timeout occurs:

```javascript
server.register(RequestTimeoutPlugin, {
  defaultTimeoutMillis: 5000,
  timeoutPayload: {
    errorType: "My custom error",
    messages: [{ message: "Custom timeout message" }],
  },
});
```

### Dynamic overriding

You can override dynamically the timeout for a given route. This can be useful for frameworks that use decorators to modify the handler.

Note: the timeout handler is set on `preHandler` hook, you need to override it sooner in the lifecycle (e.g. `onRequest`).

```javascript
import { overrideTimeout } from "@felipemocruha/fastify-route-timeout";

server.register(RequestTimeoutPlugin, {
  defaultTimeoutMillis: 5000,
});

const override = async (req: FastifyRequest, rep: FastifyReply) => {
  overrideTimeout(1000);
};

server.get(
  "/example",
  { onRequest: override },
  async (req: FastifyRequest, rep: FastifyReply) => {
    return { success: true };
  },
);
```

### Error Handling

The plugin wraps its internal errors using `FastifyRouteTimeoutError`. You should catch and handle these errors in your application the way you see fit:

```javascript
server.setErrorHandler((error, request, reply) => {
  if (error instanceof FastifyRouteTimeoutError) {
    console.error(
      "fastify-route-timeout failed unexpectedly: ",
      error.err.message,
    );
    reply.status(500).send({ error: "Internal Server Error" });
  } else {
    reply.send(error);
  }
});
```