open-index/open-npm huggingface dataset:
npm package: @qlucent/fishi-core
Description: Shared templates, types, and generators for the FISHI framework
Latest version: 0.20.6

# @qlucent/fishi-core

Shared templates, types, and generators for the [FISHI](https://github.com/kpkaranam/fishi) framework.

[![npm version](https://img.shields.io/npm/v/@qlucent/fishi-core?style=flat-square&color=0066cc)](https://www.npmjs.com/package/@qlucent/fishi-core)
[![license](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/kpkaranam/fishi/blob/master/LICENSE)

## What is this?

This is the core library powering FISHI's scaffold generator, agent templates, hook scripts, and configuration templates. It is consumed by [`@qlucent/fishi`](https://www.npmjs.com/package/@qlucent/fishi) (the CLI) and the FISHI plugin.

**You probably want [`@qlucent/fishi`](https://www.npmjs.com/package/@qlucent/fishi) instead** — that's the CLI tool you install and run.

## What's included

| Category | Count | Description |
|----------|-------|-------------|
| Agent templates | 19 | Master orchestrator, 4 coordinators, 13 workers, deep research |
| Domain agents | 4 | SaaS, Marketplace, Mobile, AI/ML architects |
| Skill templates | 13 | Brainstorming, code-gen, debugging, testing, PRD, etc. |
| Hook scripts | 17 | Session start, checkpoint, phase guard, worktree guard, etc. |
| Command templates | 8 | `/fishi-init`, `/fishi-gate`, `/fishi-board`, `/fishi-sprint`, etc. |
| Config templates | 10 | CLAUDE.md, settings.json, SOUL.md, AGENTS.md, rules, etc. |

## Usage

```typescript
import {
  generateScaffold,
  frontendAgentTemplate,
  getMasterOrchestratorTemplate,
  getClaudeMdTemplate,
} from '@qlucent/fishi-core';

// Generate a full project scaffold
await generateScaffold('./my-project', {
  projectName: 'my-app',
  projectType: 'greenfield',
  interactive: false,
  costMode: 'balanced',
  description: 'My project',
});

// Or use individual templates
const frontendAgent = frontendAgentTemplate({
  projectName: 'my-app',
  projectDescription: 'My project',
  projectType: 'greenfield',
  costMode: 'balanced',
  timestamp: new Date().toISOString(),
});
```

## Links

- [FISHI CLI (`@qlucent/fishi`)](https://www.npmjs.com/package/@qlucent/fishi) — the tool you install and run
- [GitHub](https://github.com/kpkaranam/fishi) — source code, issues, changelog
- [License](https://github.com/kpkaranam/fishi/blob/master/LICENSE) — MIT
npm package: @qlucent/fishi-governance
Description: Governance plugin for Claude Code — blocks destructive agent operations and logs an audit trail. Works with any framework.
Latest version: 0.1.1

# @qlucent/fishi-governance

**Governance plugin for Claude Code** — blocks destructive agent operations and logs an audit trail.

Works alongside **any framework**: Ruflo, BMAD, Oh-My-ClaudeCode, or raw Claude Code.

## Why?

AI agents are deleting production files, force-pushing to main, and overwriting `.env` files — right now, today. This plugin stops that.

**Before fishi-governance:**
```
Agent: "Let me clean up the project..."
> rm -rf migrations/    ← your database migrations, gone
> git push --force origin main    ← your team's work, overwritten
```

**After fishi-governance:**
```
Agent: "Let me clean up the project..."
> rm -rf migrations/
[fishi-governance] BLOCKED: Recursive delete of all files in cwd
> git push --force origin main
[fishi-governance] BLOCKED: Force push to main/master
```

## Quick Start (2 minutes)

```bash
# 1. Install the plugin
npm install -g @qlucent/fishi-governance

# 2. That's it. Start a Claude Code session.
# Destructive operations are now blocked. Audit trail is logging.
```

Zero configuration required. Works immediately.

## What It Blocks

| Category | Examples |
|----------|---------|
| Filesystem destruction | `rm -rf /`, `rm -rf *`, `mkfs`, `dd if=` |
| Dangerous git operations | `git push --force main`, `git reset --hard`, `git clean -fd` |
| Database destruction | `DROP TABLE`, `TRUNCATE TABLE`, `DELETE FROM` (no WHERE) |
| Privilege escalation | `sudo`, `su root`, `chmod 777` |
| Remote code execution | `curl ... \| bash`, `wget ... \| sh` |
| Environment exposure | `.env` file overwrites, `env >` dumps |
| System commands | `shutdown`, `reboot`, `kill -9` |

## Audit Trail

Every agent action is logged to `.fishi/audit-log.jsonl`:

```json
{"ts":"2026-04-02T12:00:00Z","event":"blocked","tool":"Bash","command":"rm -rf migrations/","reason":"Recursive delete of all files in cwd","override":false}
{"ts":"2026-04-02T12:00:01Z","event":"allowed","tool":"Write","command":"src/index.ts","reason":"","override":false}
```

- Append-only — existing entries can never be modified
- Persists across sessions
- Structured JSONL — easy to parse and review

## Works With

- **Ruflo** — governance hooks layer on top, no conflicts
- **BMAD Method** — complementary: BMAD plans, FISHI governs
- **Oh-My-ClaudeCode** — additive hooks, independent operation
- **Raw Claude Code** — standalone protection for any project
- **Full FISHI framework** — coexists with v0.20.6+

## How It Works

Three Claude Code hooks, zero dependencies:

1. **SessionStart** — confirms governance is active, creates `.fishi/` directory
2. **PreToolUse (Bash)** — checks commands against 30+ destructive patterns, blocks matches
3. **PostToolUse (Bash|Write|Edit)** — logs every action to audit trail

All processing is local. Zero network calls. Zero telemetry. Zero tracking.

## License

MIT
npm package: @qlucent/fishi-patterns
Description: Integration pattern marketplace for Claude Code — 60 battle-tested blueprints via MCP server. Stripe, Auth0, SendGrid, and more.
Latest version: 0.1.0

# @qlucent/fishi-patterns

**Integration pattern marketplace for Claude Code** — 60 battle-tested blueprints via MCP server.

Stripe, Auth0, SendGrid, PostHog, Prisma, and 55 more. Search, select, and inject into your agent's context.

## Why?

Every time you ask an AI agent to "add Stripe payments," it improvises from training data. Sometimes it works. Often it doesn't. **FISHI Patterns gives agents battle-tested blueprints** — the right packages, the right architecture, the right patterns, the right pitfalls to avoid.

**Before:**
```
You: "Add Stripe payments to my Next.js app"
Agent: *spends 30 minutes hallucinating outdated API calls*
```

**After:**
```
You: "Add Stripe payments to my Next.js app"
Agent: *pulls fishi-patterns blueprint, implements correctly in 3 minutes*
```

## Quick Start (2 minutes)

```bash
# 1. Install globally
npm install -g @qlucent/fishi-patterns

# 2. Add to Claude Code MCP config (~/.claude/settings.json)
```

Add this to your Claude Code settings under `mcpServers`:

```json
{
  "mcpServers": {
    "fishi-patterns": {
      "command": "fishi-patterns",
      "args": []
    }
  }
}
```

```bash
# 3. Use in Claude Code
# The agent can now search and use patterns:
# "Search for a Stripe payment blueprint"
# "Find an auth integration for Next.js"
```

## Available Patterns (60)

| Category | Patterns |
|----------|---------|
| Authentication | Auth0, Clerk, NextAuth.js, Supabase Auth, Custom JWT |
| Payments | Stripe, PayPal, LemonSqueezy |
| Email | SendGrid, Resend, AWS SES, Mailgun |
| Analytics | PostHog, Plausible, Mixpanel, Google Analytics |
| Database | Prisma+PostgreSQL, Drizzle, Supabase, MongoDB |
| Storage | AWS S3, Cloudinary, Supabase Storage, Cloudflare R2 |
| Search | Algolia, Meilisearch, Typesense, pgvector, Elasticsearch |
| Vector Database | Qdrant, Milvus, Pinecone, Chroma |
| Monitoring | Sentry, LogRocket, Datadog |
| CI/CD | GitHub Actions, Vercel, Docker, Railway |
| Realtime | WebSocket, Pusher, Ably, Supabase Realtime |
| And more... | Project Management, Communication, E-commerce, Design, Support, Crawlers, Hosting, Domains, Cloud |

## MCP Tools

| Tool | Description |
|------|------------|
| `search(query, category?)` | Search blueprints by keyword with optional category filter |
| `info(pattern_id)` | Get full blueprint details |
| `select(pattern_id)` | Get blueprint content ready for agent injection |
| `list_categories()` | List all categories with pattern counts |
| `contribute_template()` | Get the template for contributing new patterns |

## Contributing Patterns

See [CONTRIBUTING.md](CONTRIBUTING.md) — add your own integration blueprints!

## Works With

- **Any Claude Code project** — standalone MCP server
- **Ruflo, BMAD, Oh-My-ClaudeCode** — no conflicts
- **Full FISHI framework** — complementary, not required
- **Automated pipelines** — programmatic MCP access, no human interaction needed

## License

MIT
npm package: @qlue-ui/icon-kit
Description: <h1 align="center">Qlue Icon Kit</h1>
Author: dhegana
Latest version: 0.0.0

<h1 align="center">Qlue Icon Kit</h1>

## Quick Start

1. Download icon from UI/UX team, whatever the format icon `(SVG|PNG|JPG)` but prefer `SVG` for dynamic custom element
2. Put your Icon in diretory `assets`
3. And the last one, run command `yarn build` and automatically icon will be generated

## How to use

```jsx
import { Camera } from "@qlue/icon-kit";

export default function MyPage() {
  return <Camera />;
}
```
npm package: @qlue-ui/ui-kit
Description: Qlue-UI. The component library from Qlue
Author: qlue-dev
Latest version: 0.0.0

<h1 align="center">Qlue UI Kit</h1>

## Prolog

First of all we started creating atomic design, for further reading you can follow this original course [CLICK HERE](https://bradfrost.com/blog/post/atomic-web-design/), the outline is please make sure your new component is corresponding to target of Atomic Design which are atoms, molecules and so on.

## Quick Start

How to include this UI-kit with your awesome project

1. Run command `yarn lerna add @qlue/ui-kit --scope @qlue/you-new-project`
2. And then in your root component wrap with the Provider `QlueUIProvider`

```jsx
import React from "react";
import ReactDOm from "react-dom";
import { QlueUIProvider } from "@qlue/ui-kit";

function Root() {
  return (
    <QlueUIProvider configName="CRMDashboard">
      <App />
    </QlueUIProvider>
  );
}

ReactDOM.render(<Root />, document.getElementById("root"));
```

3. And then corresponding `configName` what you want, if want to create new color, updated a config in `variables.js` and then if you want to use existing color project just fill in with project name in accordance with the `variables.js` file.

## How to Contribute

The simple if you want to contribute to this repo

1. Fork the repository
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push -u origin my-new-feature`
5. Create a Pull Request!
npm package: @qlue/icon-kit
Description: <h1 align="center">Qlue Icon Kit</h1>
Author: qlue-dev
Latest version: 0.0.1

<h1 align="center">Qlue Icon Kit</h1>

## Quick Start

1. Download icon from UI/UX team, whatever the format icon `(SVG|PNG|JPG)` but prefer `SVG` for dynamic custom element
2. Put your Icon in diretory `assets`
3. And the last one, run command `yarn build` and automatically icon will be generated

## How to use

```jsx
import { Camera } from '@qlue/icon-kit'

export default function MyPage() {
  return <Camera />
}
```
npm package: @qlue/ui-kit
Description: Qlue-UI. The component library from Qlue
Author: qlue-dev
Latest version: 0.0.0

<h1 align="center">Qlue UI Kit</h1>

## Prolog

First of all we started creating atomic design, for further reading you can follow this original course [CLICK HERE](https://bradfrost.com/blog/post/atomic-web-design/), the outline is please make sure your new component is corresponding to target of Atomic Design which are atoms, molecules and so on.

## Quick Start

How to include this UI-kit with your awesome project

1. Run command `yarn lerna add @qlue/ui-kit --scope @qlue/you-new-project`
2. And then in your root component wrap with the Provider `QlueUIProvider`

```jsx
import React from "react";
import ReactDOm from "react-dom";
import { QlueUIProvider } from "@qlue/ui-kit";

function Root() {
  return (
    <QlueUIProvider configName="CRMDashboard">
      <App />
    </QlueUIProvider>
  );
}

ReactDOM.render(<Root />, document.getElementById("root"));
```

3. And then corresponding `configName` what you want, if want to create new color, updated a config in `variables.js` and then if you want to use existing color project just fill in with project name in accordance with the `variables.js` file.

## How to Contribute

The simple if you want to contribute to this repo

1. Fork the repository
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push -u origin my-new-feature`
5. Create a Pull Request!
npm package: @qm-hub/sync-client-types
Description: TypeScript types for qm-sync-client - generated from Rust with Specta
Latest version: 0.2.3

# @qm-hub/sync-client-types

TypeScript types and browser/Node.js client for qm-sync-client - types generated from Rust with Specta.

## Installation

```bash
npm install @qm-hub/sync-client-types
```

## Usage

### Config helper

```typescript
import { createSyncClientConfig, QmSyncClient } from '@qm-hub/sync-client-types';

const config = createSyncClientConfig(
  'https://sync.example.com',
  'my-app-id',
  'my-api-key',
  {
    defaultBatchSize: 100,
    timeoutMs: 30000,
    apiBasePath: '/api/v1', // optional, default is "/api/v1"
  }
);

const client = new QmSyncClient(config);
```

### Authentication

```typescript
await client.login('user@example.com', 'password');

// Restore from stored tokens
client.setTokens(accessToken, refreshToken, userId);

// Persist tokens
const { accessToken, refreshToken } = client.getTokens();
```

### Sync operations

```typescript
// Push local changes
const pushResult = await client.push(records);

// Pull remote changes
const pullResult = await client.pull(checkpoint, batchSize);

// Delta sync (push + pull in one request)
const deltaResult = await client.delta(records, checkpoint);
```

### Custom HTTP transport

```typescript
import { QmSyncClient, type HttpClientFn } from '@qm-hub/sync-client-types';

const myHttpClient: HttpClientFn = async (request) => {
  // custom fetch logic
};

const client = new QmSyncClient(config, myHttpClient);
```

## SyncClientConfig

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `serverUrl` | `string` | — | Base URL of the sync server |
| `appId` | `string` | — | Application ID |
| `apiKey` | `string` | — | API key for the application |
| `defaultBatchSize` | `number` | `100` | Default pull batch size |
| `timeoutMs` | `number` | `30000` | Request timeout in ms |
| `apiBasePath` | `string` | `"/api/v1"` | Prefix for all API endpoints |

## Regenerating Types

Types are generated from Rust using Specta. To regenerate after modifying Rust structs:

```bash
cargo run -p qm-sync-client --bin export_types
```

Then update `src/index.ts` with the generated types.

## Local Development

```bash
npm install
npm run build
npm link

# In your project
npm link @qm-hub/sync-client-types
```

## Publishing

```bash
npm run build
npm publish --access public

npm view @qm-hub/sync-client-types
```