open-index/open-npm huggingface dataset:
npm package: @rikkei-org/git-isuse-workflows
Description: BMAD custom workflows for Okami projects: issue-investigate, issue-implement, issue-mr
Author: TheCM
Latest version: 1.0.0

# @okami/bmad-workflows

BMAD custom workflows for Okami projects. Installs 3 specialized workflows into any project with BMAD Method.

## Workflows

| Command | Description |
|---------|-------------|
| `/issue-investigate <URL>` | Investigate a GitHub/GitLab issue, analyze code, save local report |
| `/issue-implement <URL>` | Implement changes from investigation + create PR |
| `/issue-mr` | Analyze branch diff, create MR summary (Japanese), execute merge |

## Prerequisites

- [BMAD Method](https://github.com/bmad-code-org/BMAD-METHOD) installed with **BMM** module
- Node.js v20+
- `gh` CLI installed and authenticated
- `git` CLI installed

## Installation

```bash
# From your project root (where _bmad/ exists)
npx @okami/bmad-workflows
```

### Options

```bash
npx @okami/bmad-workflows --dir /path/to/project   # Specify project root
npx @okami/bmad-workflows --force                   # Overwrite existing files
npx @okami/bmad-workflows --dry-run                 # Preview without writing
npx @okami/bmad-workflows --help                    # Show help
```

## Post-Install

Edit `_bmad/bmm/config.yaml` in your project:

```yaml
user_name: <your name>
project_name: <project name>
communication_language: <language>
```

## Uninstall

```bash
node node_modules/@okami/bmad-workflows/uninstall.js
# or
npx @okami/bmad-workflows uninstall
```

## What Gets Installed

```
_bmad/bmm/workflows/4-implementation/
├── issue-investigate/          ← workflow config
├── issue-implement/            ← workflow config
└── issue-mr/                   ← workflow config

.agent/workflows/
├── bmad-bmm-issue-investigate.md   ← trigger
├── bmad-bmm-issue-implement.md     ← trigger
└── bmad-bmm-issue-mr.md            ← trigger
```

## License

MIT
npm package: @rikstv/shared-components
Description: Wrap your app with you preferred brand. The css needs to be imported manually once in the app.
Latest version: 3.3.19

# Shared-components

Wrap your app with you preferred brand. The css needs to be imported manually once in the app.

```
import { Strim, PrimaryButton, DisplayTitle } from '@rikstv/shared-components";
import '@rikstv/shared-components/dist/style.css";

const Root = () => (
    <Strim>
        <main>
            <DisplayTitle>
                MyApp
            </DisplayTitle>

            <PrimaryButton>
                Hello world
            </PrimaryButton>
        </main>
    </Strim>
)
```
npm package: @riktajs/core
Description: A fast and modern TypeScript backend framework with zero-config autowiring, powered by Fastify
Author: riktar
Latest version: 0.11.5

# @riktajs/core

The core package of the Rikta framework.

See the [main repository README](../../README.md) for full documentation.

## Installation

```bash
npm install @riktajs/core
```

## Quick Start

```typescript
import { Rikta, Controller, Injectable, Get, Autowired } from '@riktajs/core';

@Injectable()
class HelloService {
  getMessage() {
    return { message: 'Hello from Rikta!' };
  }
}

@Controller('/api')
class HelloController {
  @Autowired()
  private helloService!: HelloService;

  @Get('/hello')
  getHello() {
    return this.helloService.getMessage();
  }
}

const app = await Rikta.create({ 
  port: 3000, 
  autowired: ['./src']
});
await app.listen();
```

## Features

- 🚀 Zero-Config Autowiring
- ⚡ Fastify Powered
- 🛡️ Type-Safe by Default
- 🔄 Hybrid Lifecycle
- 📦 Built-in Dependency Injection
- ✅ Zod Validation Integration

## Provider Scopes

Rikta supports three provider scopes:

```typescript
// Singleton (default) - shared instance
@Injectable()
class ConfigService {}

// Transient - new instance each time
@Injectable({ scope: 'transient' })
class RequestLogger {}

// Request - one instance per HTTP request
@Injectable({ scope: 'request' })
class RequestContext {}
```

## Strict Discovery Mode

Enable strict discovery to catch import errors early:

```typescript
const app = await Rikta.create({
  strictDiscovery: process.env.NODE_ENV !== 'production',
  onDiscoveryError: (file, error) => {
    console.warn(`Failed to import: ${file}`);
  },
});
```

## EventBus

The EventBus provides pub/sub for lifecycle events:

```typescript
import { Injectable, Autowired, EventBus } from '@riktajs/core';

@Injectable()
class MonitorService {
  @Autowired()
  private events!: EventBus;

  onProviderInit() {
    this.events.on('app:listen', ({ address }) => {
      console.log(`Server at ${address}`);
    });
  }
}
```

## Interceptors

Interceptors allow you to bind extra logic before/after method execution:

```typescript
import { Injectable, Interceptor, ExecutionContext, CallHandler, UseInterceptors } from '@riktajs/core';

@Injectable()
class LoggingInterceptor implements Interceptor {
  async intercept(context: ExecutionContext, next: CallHandler): Promise<unknown> {
    const start = Date.now();
    const result = await next.handle();
    console.log(`Request took ${Date.now() - start}ms`);
    return result;
  }
}

@Controller('/api')
@UseInterceptors(LoggingInterceptor)
class ApiController {
  @Get('/data')
  getData() {
    return { data: 'example' };
  }
}
```

## License

MIT
npm package: @riktar/frontman
Description: Opinionated CLI for automate frontend task
Author: Riccardo Tartaglia @riktar
Latest version: 0.2.0

# Frontman

An opinionated CLI for automate frontend task

[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![Version](https://img.shields.io/npm/v/frontman.svg)](https://npmjs.org/package/frontman)
[![Downloads/week](https://img.shields.io/npm/dw/frontman.svg)](https://npmjs.org/package/frontman)
[![License](https://img.shields.io/npm/l/frontman.svg)](https://github.com/riktar/frontman/blob/master/package.json)
npm package: @rikthepixel/fuzzystring
Description: Simple fuzzy search library written in TypeScript
Latest version: 1.1.1

# fuzzystring

Simple fuzzy search library written in TypeScript

Alows partial matching of requested string. Useful for searching large sets of data without requesting acureate and full user input.

## Demo

[Click here for demo](https://pie6k.github.io/fuzzystring/)

![screen recording 2018-12-05 at 21 35 33](https://user-images.githubusercontent.com/7311462/49559878-ed6f0a80-f8d5-11e8-8cf6-fd5734512f9f.gif)

## Install

- Using npm: `npm add fuzzystring`
- Using yarn: `yarn add fuzzystring`

```ts
import { fuzzyString } from 'fuzzystring';
```

## Api

```ts
fuzzyString('liolor', 'lorem ipsum dolor sit');
// Outputs: 0.87
```

## Performance

```ts
console.time('measure');
for (let i = 0; i < 100000; i++) {
  fuzzyString(`ive ${i} lles`, `i have ${i} apples`);
}
console.timeEnd('measure');
// measure: 271.169921875ms
```

~200k ops/s [jsperf](https://jsperf.com/fuzzystring2)

## Development

Test

`npm run test`

Build

`npm run build`
npm package: @riku/intersperse
Description: Add an object to an array between each element
Author: Glen Huang
Latest version: 1.1.1

# intersperse

Add an object to an array between each element.


## Installation

	npm install @riku/intersperse

## Example

```javascript
var intersperse = require('intersperse');
var arr = intersperse([1, 2, 3], 'a');

console.log(arr) // [1, 'a', 2, 'a', 3]
```