open-index/open-npm huggingface dataset:
npm package: @stackup-ui/eslint-config
Description: ESLint configuration.
Author: Wesley Barbosa
Latest version: 1.0.0

# @stackup-ui/eslint-config

[![npm][npm-image]][npm-url]
[![downloads][downloads-image]][downloads-url]
[![standard][standard-image]][standard-url]

[npm-image]: https://img.shields.io/npm/v/@stackup-ui/eslint-config/latest.svg
[npm-url]: https://www.npmjs.com/package/@stackup-ui/eslint-config
[downloads-image]: https://img.shields.io/npm/dm/@stackup-ui/eslint-config
[downloads-url]: https://npmjs.org/package/@stackup-ui/eslint-config
[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
[standard-url]: https://standardjs.com

## Getting Started

1. Install the dependencies.

**npm:**

```bash
npm i -D eslint @stackup-ui/eslint-config
```

**yarn:**

```bash
yarn add -D eslint @stackup-ui/eslint-config
```

2. Create a `.eslintrc.*` file.

**JSON:**

```json
{
  "extends": ["@stackup-ui/eslint-config"]
}
```

**JS:**

```js
module.exports = {
  extends: ["@stackup-ui/eslint-config"]
}
```
npm package: @stackup-ui/react
Description: React components that implement StackUp UI Styles.
Author: Wesley Barbosa
Latest version: 1.0.1

# @stackup-ui/react

React components that implement [StackUp UI Styles](https://github.com/wesleey/stackup-ui/packages/styles).

[![npm][npm-image]][npm-url]
[![downloads][downloads-image]][downloads-url]

[npm-image]: https://img.shields.io/npm/v/@stackup-ui/react/latest.svg
[npm-url]: https://www.npmjs.com/package/@stackup-ui/react
[downloads-image]: https://img.shields.io/npm/dm/@stackup-ui/react
[downloads-url]: https://npmjs.org/package/@stackup-ui/react

## Installation

Install the package in your project directory with:

```bash
// with npm
npm install @stackup-ui/react

// with yarn
yarn add @stackup-ui/react
```

## Documentation

[The documentation](https://wesleey.github.io/stackup-ui)
npm package: @stackup/codegen
Description: Generate types for a GraphQL API
Latest version: 0.10.0

<h1 align="center">@stackup/codegen</h1>

<div align="center">

![Build](https://github.com/rzane/codegen/workflows/Build/badge.svg)
![Version](https://img.shields.io/npm/v/@stackup/codegen)
![License](https://img.shields.io/npm/l/@stackup/codegen)

</div>

A zero-config CLI tool to generate GraphQL type definitions and React Hooks. It's a thin wrapper around [GraphQL code generator](https://graphql-code-generator.com/).

## Install

    $ yarn add @stackup/codegen --dev
    $ yarn codegen --help
    Generate type definitions from GraphQL queries.

    USAGE
      $ @stackup/codegen ROOT

    ARGUMENTS
      ROOT  directory where your GraphQL queries live

    OPTIONS
      -s, --schema=schema  (required) URL or file path to the GraphQL schema
      -t, --types=types    declare type for a custom scalar
      --colocate=colocate  generate files adjacent to their GraphQL source
      --help               show CLI help
      --immutable          generate readonly types
      --show-config        show the generated configuration
      --suffix             append a suffix to generated types
      --version            show CLI version

## Usage

You have a directory of queries:

    src/
      queries/
        posts.graphql
        users.graphql

Run the code generator:

    $ yarn codegen src/queries --schema http://localhost:3000/graphql

Now, you have code!

    src/
      queries/
        index.ts       <- This module exports typed React Hooks
        schema.graphql <- This file contains your GraphQL schema
        posts.graphql
        users.graphql

Import the typed document node and use a query:

```typescript
import { useQuery } from "@apollo/client"
import { UserDocument } from "../queries";

useQuery(UserDocument);
```

## Colocated Queries

What if you want your queries to live next to your components?

    src/
      components/
        User/
          User.tsx
          queries.graphql

Run the code generator:

    $ yarn codegen src --colocate src/queries --schema http://localhost:3000/graphql

Now, your file tree should look like this:

    src/
      queries/
        index.ts       <- This module exports your schema's types
        schema.graphql <- This file contains your GraphQL schema
      components/
        User/
          User.tsx
          queries.graphql
          queries.ts   <- This module exports typed React hooks
npm package: @stackup/eslint-config
Description: An ESLint configration metapackage
Latest version: 1.0.1

<h1 align="center">@stackup/eslint-config</h1>

<div align="center">

![Build](https://github.com/rzane/eslint-config/workflows/Build/badge.svg)
![Version](https://img.shields.io/npm/v/@stackup/eslint-config)
![License](https://img.shields.io/npm/l/@stackup/eslint-config)

</div>

A metapackage for ESLint configuration for TypeScript projects.

The following plugins are integrated:

- `eslint-plugin-import`
- `eslint-plugin-jsx-a11y`
- `eslint-plugin-prettier`
- `eslint-plugin-react`
- `eslint-plugin-react-hooks`

## Usage

If you're starting a project from scratch, just run the following commands:

    $ yarn add eslint prettier @stackup/eslint-config --dev

If you're using React, your configuration should look like this:

```json
{
  "root": true,
  "extends": ["@stackup/eslint-config", "@stackup/eslint-config/react"],
  "parserOptions": {
    "project": "./tsconfig.json"
  },
  "settings": {
    "react": {
      "version": "detect"
    }
  }
}
```

Otherwise, your configuration should look like this:

```json
{
  "root": true,
  "extends": ["@stackup/eslint-config"],
  "parserOptions": {
    "project": "./tsconfig.json"
  }
}
```

Add the following script to your `package.json`:

```
"scripts": {
  "lint": "eslint . --ext .ts,.tsx",
}
```
npm package: @stackup/factory
Description: Define factories to clean up fake data generation in tests
Latest version: 0.2.1

<h1 align="center">@stackup/factory</h1>

<div align="center">

![Build](https://github.com/rzane/factory/workflows/build/badge.svg)
![Version](https://img.shields.io/npm/v/@stackup/factory)
![Size](https://img.shields.io/bundlephobia/minzip/@stackup/factory)
![License](https://img.shields.io/npm/l/@stackup/factory)

</div>

## Install

    $ yarn add @stackup/factory --dev

## Usage

First, you'll need to define a factory:

```javascript
import { factory } from "@stackup/factory";

const UserFactory = factory({
  id: 1,
  name: "Rick",
});
```

Great, now to use that factory, just call the `build` method:

```javascript
UserFactory.build();
// { id: 1, name: "Rick" }
```

You can override some of the properties, too:

```javascript
UserFactory.build({ name: "Ray" });
// { id: 1, name: "Ray" }
```

Generate an array:

```javascript
UserFactory.array(2).build();
// [
//   { id: 1, name: "Rick" },
//   { id: 1, name: "Rick" }
// ]
```

Your factories can reuse other factories:

```javascript
const ProfileFactory = factory({
  user: UserFactory,
  friends: UserFactory.array(2),
});

ProfileFactory.build();
// {
//   user: { id: 1, name: "Rick" },
//   friends: [{ id: 1, name: "Rick" }, { id: 1, name: "Rick" }]
// }
```

Need something to be unique?

```javascript
import { sequence } from "@stackup/factory";

const UserFactory = factory({
  email: sequence((n) => `${n}@example.com`),
});

UserFactory.build();
// { email: "78@example.com" }

UserFactory.build();
// { email: "79@example.com" }
```

Want random data?

```javascript
import { random } from "@stackup/factory";

const UserFactory = factory({
  name: random((chance) => chance.name()),
});

UserFactory.build();
// { name: "Leona Floyd" }

UserFactory.build();
// { name: "Max Copeland" }
```

## Fixtures

If you're snapshot testing, random data will break your tests. In that case, you
can generate data deterministically:

```javascript
UserFactory.fixture();
// { name: "Abe" }

UserFactory.fixture();
// { name: "Abe" }
```
npm package: @stackvoid/vaultgen
Description: A minimalist CLI password manager secured with local master key encryption and seamless clipboard integration.
Author: Sebastian Marat Urdanegui Bisalaya
Latest version: 1.0.3

# **VaultGen CLI**

### **Description**

**VaultGen** is a minimalist, terminal-based password manager designed for developers who value security and efficiency. 
Built to operate entirely within the CLI, it leverages local master key encryption to ensure your credentials never leave your machine. With intuitive commands, it streamlines the process of generating, storing, and accessing passwords while keeping your workflow focused and clutter-free.

### **How does it work?**

VaultGen uses a user-provided password to securely encrypt all credentials using the `AES-256-GCM` algorithm. Instead of using the password directly, a cryptographic key is derived from it using the `scrypt` key derivation function. This derived key is what is actually used for encryption.

`AES-256-GCM` uses a **12-byte** initialization vector (IV), randomly generated for each encryption. This ensures that encrypting the same plaintext with the same key produces different ciphertext every time, providing semantic security.

A **32-byte** salt is also used during key derivation. The salt ensures that the same password will produce different derived keys, preventing attacks based on precomputed tables such as rainbow tables.

The Master Key is never stored and only exists in memory during the session. To validate the `Master Key` without storing it, `VaultGen` encrypts a known verification string during vault initialization and sabes the resulting ciphertext. On every subsequent operation, it attempts to decrypt this verifier —— if the result matches, the Master Key is accepted; otherwise, it is rejected. The Master Key itself is never persisted anywhere.

`AES-256-GCM` also provides built-in authentication via an authentication tag. This ensures that encrypted data cannot be tampered with without detection.

### **Installation**

Using `npm`:

```bash
npm install -g @stackvoid/vaultgen
```

Using `pnpm`:

```bash
pnpm install -g @stackvoid/vaultgen
```

### **Usage**

```bash
# Create a new vault
vaultgen init

# Add a new credential to the vault
vaultgen new

# List all credentials in the vault and copy to clipboard
vaultgen list

# Remove a credential from the vault
vaultgen delete

# Update an existing credential
vaultgen update

# Analyze all credentials for security vulnerabilities
vaultgen audit

# Completely wipe the vault — all credentials, metadata and config
vaultgen reset
```

### **Commands**

| **Command** | **Description** |
| --- | --- |
| `vaultgen init` | Initialize the local vault. |
| `vaultgen new` | Add a new credential to the vault. |
| `vaultgen list` | List all credentials in the vault and copy to clipboard. |
| `vaultgen delete` | Remove a credential from the vault. |
| `vaultgen update` | Update an existing credential. |
| `vaultgen audit` | Analyze all credentials for security vulnerabilities. |
| `vaultgen reset` | Completely wipe the vault — all credentials, metadata and config. |


### **License**

MIT License
npm package: @stackweld/core
Description: Core engine for Stackweld — rules, scaffold orchestrator, runtime manager, tech installer, and SQLite persistence.
Author: Orlando Fernandez
Latest version: 0.4.0

# @stackweld/core

[![Version](https://img.shields.io/badge/version-0.4.0-blue.svg)](https://github.com/mundowise/Stackweld/releases)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The core engine for Stackweld. Handles stack persistence, compatibility rules, scaffolding orchestration, Docker lifecycle, and all analysis modules.

This package is an internal dependency — you do not use it directly. Install `@stackweld/cli` instead.

## What it contains

```
src/
  db/          SQLite persistence layer (better-sqlite3)
  docker/      Docker Compose generation and runtime manager
  engine/      All analysis and intelligence modules:
               compatibility, env-sync, detect, compose-preview,
               health, migration, diff, share, infra, lint,
               benchmark, cost, learn, plugin
  scaffold/    Scaffold orchestrator + tech installer
  types/       Shared TypeScript types
  index.ts     Public API surface
```

### Key exports

```typescript
import {
  StackEngine,         // Create, save, load, delete stacks (SQLite)
  RulesEngine,         // Validate technology combinations, resolve dependencies
  ScaffoldOrchestrator,// Run official CLI tools (create-next-app, django-admin...)
  TechInstaller,       // Install per-technology extras (Prisma, NextAuth, Vitest...)
  DockerManager,       // docker compose up/down/status/logs
  scoreCompatibility,  // Score two technologies (0-100)
  checkProjectHealth,  // Audit an existing project directory
  planMigration,       // Step-by-step migration plan between technologies
  estimateCost,        // Monthly hosting cost estimate across providers
  detectStack,         // Detect stack from existing project files
  generateInfra,       // Generate Dockerfile + nginx / CloudFormation / Terraform
} from '@stackweld/core';
```

## Requirements

- Node.js >= 22.0.0
- Docker + Docker Compose (for runtime operations)

## Repository

[github.com/mundowise/Stackweld](https://github.com/mundowise/Stackweld)

## License

MIT
npm package: @stackweld/registry
Description: Technology registry for Stackweld — 83 YAML technology definitions with JSON Schema validation.
Author: Orlando Fernandez
Latest version: 0.4.0

# @stackweld/registry

[![Version](https://img.shields.io/badge/version-0.4.0-blue.svg)](https://github.com/mundowise/Stackweld/releases)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The technology registry for Stackweld. Contains 83 YAML technology definitions with JSON Schema validation, covering compatibility rules, dependencies, ports, and scaffold instructions.

This package is an internal dependency — you do not use it directly. Install `@stackweld/cli` instead.

## What it contains

83 technology definitions across 9 categories:

| Category | Count | Examples |
|----------|-------|---------|
| Runtime | 7 | Node.js, Python, Go, Rust, Bun, Deno, PHP |
| Frontend | 12 | Next.js, React, Vue, Nuxt, Svelte, SvelteKit, Astro, Angular |
| Backend | 12 | Express, FastAPI, Django, Gin, Hono, NestJS, Laravel |
| Database | 11 | PostgreSQL, MySQL, MongoDB, Redis, SQLite, Supabase |
| ORM | 6 | Prisma, Drizzle, SQLAlchemy, TypeORM, Django ORM, Mongoose |
| Auth | 4 | NextAuth, Clerk, Lucia, Supabase Auth |
| Styling | 6 | Tailwind CSS, shadcn/ui, Chakra UI, Material UI |
| Service | 10 | Nginx, Traefik, MinIO, Grafana, Prometheus, pgAdmin |
| DevOps | 15 | Docker, TypeScript, Vitest, Jest, Playwright, GitHub Actions |

Each definition specifies:
- `id`, `name`, `category`, `description`
- `dockerImage` and `port` (for services)
- `incompatibleWith` — technologies that cannot be combined
- `requires` — technologies that must be included if this one is selected
- `scaffoldCmd` — the official CLI command used to scaffold this technology

## Repository

[github.com/mundowise/Stackweld](https://github.com/mundowise/Stackweld)

## License

MIT
npm package: @stackweld/templates
Description: Built-in stack templates for Stackweld — 20 ready-to-use project templates.
Author: Orlando Fernandez
Latest version: 0.4.0

# @stackweld/templates

[![Version](https://img.shields.io/badge/version-0.4.0-blue.svg)](https://github.com/mundowise/Stackweld/releases)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Built-in stack templates for Stackweld. 20 curated, ready-to-use project templates that you can scaffold with a single command.

This package is an internal dependency — you do not use it directly. Install `@stackweld/cli` instead.

## Available templates

| Template | Description |
|----------|-------------|
| `t3-stack` | T3 Stack (Next.js + tRPC + Prisma + Tailwind) |
| `django-rest` | Django REST API with PostgreSQL |
| `fastapi-react` | FastAPI backend + React frontend |
| `go-microservice` | Go microservice with Gin |
| `astro-landing` | Astro landing page |
| `sveltekit-fullstack` | SvelteKit full-stack app |
| `nuxt3-app` | Nuxt 3 application |
| `express-api` | Express REST API |
| `hono-microservice` | Hono microservice |
| `django-react` | Django + React full-stack |
| `mern-stack` | MERN stack (MongoDB + Express + React + Node) |
| `saas-starter` | SaaS starter with auth, billing, and admin |
| `nestjs-api` | NestJS API with TypeORM and PostgreSQL |
| `remix-fullstack` | Remix full-stack application |
| `solidstart-app` | SolidStart application |
| `laravel-app` | Laravel application with MySQL |
| `python-ai-lab` | Python AI/ML workspace with Jupyter |
| `tauri-desktop` | Tauri 2 desktop application |
| `monorepo-starter` | Turborepo monorepo with shared packages |
| `htmx-django` | HTMX + Django (zero JS framework) |

## Usage

```bash
# List all templates
stackweld template list

# Scaffold from a template
stackweld create t3-stack --path /home/user/projects

# Save your own stack as a template
stackweld template save my-stack-id

# Use a custom saved template
stackweld template use-custom my-template
```

## Repository

[github.com/mundowise/Stackweld](https://github.com/mundowise/Stackweld)

## License

MIT
npm package: @stackworx/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 2.1.1-2

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://github.com/facebook/create-react-app/blob/master/README.md#getting-started) – How to create a new app.
- [User Guide](https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md) – How to develop apps bootstrapped with Create React App.
npm package: @stackworx/relay-extractor
Description: Relay Query Extractor for Testing
Latest version: 0.0.4

# Read Me

[![CI](https://img.shields.io/github/actions/workflow/status/stackworx/RelayExtractor/ci.yml?branch=main)](https://github.com/stackworx/RelayExtractor/actions/workflows/ci.yml)
[![npm version](https://img.shields.io/npm/v/%40stackworx%2Frelay-extractor)](https://www.npmjs.com/package/@stackworx/relay-extractor)

This project is meant to extract all the GraphQL operations from a relay project
and clean them so that a client can be generated

## CLI Usage

Extract operations from a source folder to an output directory. Optionally provide a schema (SDL or introspection JSON) and exclude subscriptions.

```bash
npx @stackworx/relay-extractor \
	extract \
	--src ./src \
	--out ./out \
	--schema ./schema.graphql \
	--exclude-subscriptions
```

- **`--exclude-subscriptions`**: When set, subscription operations are skipped and not written to the output.

Annotate your schema SDL to mark unused fields (based on operations found in source files).

```bash
npx @stackworx/relay-extractor \
	annotate-unused \
	--src ./src \
	--schema ./schema.graphql
```

By default this overwrites the file passed to `--schema`. To write somewhere else (or to stdout):

```bash
# Write to a different file
npx @stackworx/relay-extractor annotate-unused --src ./src --schema ./schema.graphql --out ./schema.annotated.graphql

# Print to stdout
npx @stackworx/relay-extractor annotate-unused --src ./src --schema ./schema.graphql --out -
```

- Default annotation mode is `@deprecated(reason: "relay-extractor: unused")`.
- Use `--mode directive --directive-name unused` to apply a custom directive instead.

## Issues

- Remove Relay Compiler Directives
- Remove Relay Interla fields (`__id`)
- Handle missing arguments that relay handles with `argumentDefinitions`

## Testing: Vitest + GraphQL fix

- Background: When running Vitest with GraphQL-related tooling, you may see errors like:
	"Cannot use GraphQLSchema ... from another module or realm" due to how module resolution handles `graphql` subpath imports.
- Fix: Add aliases so Vitest resolves the ESM entry points consistently. This is configured in `vitest.config.ts`:

	```ts
	import { defineConfig } from 'vitest/config'

	export default defineConfig({
		resolve: {
			alias: {
				'graphql/language/printer': 'graphql/language/printer.js',
				'graphql/language': 'graphql/language/index.js',
				graphql: 'graphql/index.js',
			},
		},
	})
	```

- Reference: https://github.com/vitest-dev/vitest/issues/4605#issuecomment-1847658160
- Run tests:
	```bash
	npm run test -- --run
	```
npm package: @stackworx/relay-mock-network-layer
Description: Relay modern network layer that returns schema correct mock data
Author: Rob Richard
Latest version: 2.1.0

# relay-mock-network-layer
Provides a network layer for relay modern that returns schema-correct mock data using `addMockFunctionsToSchema` from [`graphql-tools`](http://dev.apollodata.com/tools/graphql-tools/mocking.html#Default-mock-example);

This is useful for working in an environment like [storybook](https://github.com/storybooks/storybook) where you want to work on your components without hitting a live GraphQL server.

## Usage
```js
import {
	Environment,
	Network,
	RecordSource,
	Store
} from 'relay-runtime';
import getNetworkLayer from 'relay-mock-network-layer';
import schema from './graphql.schema.json';

const network = Network.create(getNetworkLayer({
    schema,
    // pass custom mocks as documented in graphql-tools
    // http://dev.apollodata.com/tools/graphql-tools/mocking.html#Customizing-mocks
    mocks: {
        Geography: () => ({
            id: '2',
            countries: [{
                abbreviation: 'US',
                name: 'United States'
            }, {
                abbreviation: 'UK',
                name: 'United Kingdom'
            }],
                usStates: [{
                abbreviation: 'NY',
                name: 'New York'
            }, {
                abbreviation: 'NJ',
                name: 'New Jersey'
            }]
        }),
        Address: () => ({
            country: 'US',
            city: 'New York',
            state: 'NY',
            zipCode: '10012',
        })
    },

    // See https://www.apollographql.com/docs/graphql-tools/mocking.html#Mocking-interfaces
    preserveResolvers: false,

    // Forward along other options to `makeExecutableSchema`.
    ...schemaDefinitionOptions
}));

// Create an environment using this network:
const store = new Store(new RecordSource());
const environment = new Environment({network, store});

// use environment in <QueryRenderer>

```

### Mocking custom scalar types
If your schema has custom scalar types you'll need to use the `resolvers` option to ensure those types get mocked correctly. Pass this option an object containing a resolve function for each custom scalar.

```js
...
import getNetworkLayer from 'relay-mock-network-layer';
import {GraphQLScalarType} from 'graphql';

...

getNetworkLayer({
    schema,
    mocks: {...},
    resolvers: {
        CustomScalar: new GraphQLScalarType({
            name: 'CustomScalar',
            parseLiteral: () => {},
            parseValue: () => {},
            serialize: () => {}
        }),
        CustomScalar2: ...
    }
});
```