open-index/open-npm huggingface dataset:
npm package: @forgedock/fd-fastest-analyzer-next
Description: Next.js build analyzer with advanced module-level insights
Author: ForgeDock
Latest version: 1.0.2

# @fd-fastest/analyzer-next

Advanced Next.js bundle analyzer used by the FD-Fastest CLI.

## Features

- Route-level bundle sizing with gzip measurements.
- Module breakdown sourced from emitted source maps.
- Duplicate module detection across shared bundles.
- Dependency graph generation for quick visualization.
- Bundle composition summary highlighting framework, vendor, and app code.
- Turbopack manifest support for projects using Next.js' new bundler.

## Usage

```ts
import { analyzeNextBuild } from '@fd-fastest/analyzer-next';
import { createLogger } from '@fd-fastest/logger';

const logger = createLogger({ name: 'analyzer-example' });

const results = await analyzeNextBuild('.next', {
  advanced: true,
  detectDuplicates: true,
  generateGraph: true,
  analyzeComposition: true,
  turbopackBundleAnalysis: true,
});

logger.info('Route analysis', {
  route: results[0]?.path,
  modules: results[0]?.modules,
});
```

All advanced capabilities are opt-in and require source maps to be present in the Next.js build output. Turbopack support is on by default and falls back to webpack manifests when `.next/turbopack` is absent; set `turbopackBundleAnalysis: false` to disable the automatic detection.
npm package: @forgedock/fd-fastest-cli
Description: CLI for FD-Fastest performance testing toolkit
Author: ForgeDock
Latest version: 1.0.14

# @forgedock/fd-fastest-cli

Command-line orchestrator for the FD-Fastest performance testing toolkit. The CLI wraps Playwright-driven lab runs, configuration discovery, and report generation so you can measure Next.js applications end to end.

## Features

- ⚙️ Commander-based CLI with `fd-fastest lab` and `fd-fastest init`
- 🌐 Playwright automation with device + network throttling
- 📊 Web Vitals aggregation from `@forgedock/fd-fastest-runtime-next`
- 📦 JSON report generation using `@forgedock/fd-fastest-reporter-json`
- 🪵 Git context capture for every run

## Usage

```bash
pnpm install
pnpm --filter @forgedock/fd-fastest-cli build

# scaffold config
pnpm fd-fastest init

# run lab tests (ensure your app is running locally)
pnpm fd-fastest lab
```

Use `fd-fastest lab --config path/to/config.ts` to target a custom configuration file. Reports are written to the directory defined in the config (`reports` by default) and include a trace archive plus budget validation output.

## Simulated Interactions (INP)

Lab runs now perform lightweight, configurable user interactions so Interaction to Next Paint (INP) is populated without manual scripting. Tune the behaviour via the `interactions` block in your config:

```ts
export default {
  // ...
  interactions: {
    enabled: true,
    strategy: 'first-clickable', // 'selector' or 'random'
    // selector: '#primary-cta', // required when strategy === 'selector'
    interactionTypes: ['click', 'keypress'],
    waitAfterHydration: 1000,
    postInteractionDelay: 750,
  },
};
```

The CLI waits for hydration, executes the requested actions (click, keypress, input), and then allows a short buffer so `web-vitals` can report INP. Disable the block entirely (`enabled: false`) if your app has its own scripted interactions.

## Turbopack Bundle Analysis

When `next.analyzeBundles` is enabled, the CLI automatically inspects Turbopack production builds by reading the manifests under `.next/turbopack`. Disable this behaviour with `next.turbopackBundleAnalysis = false` if you only want classic webpack manifest parsing.

## PageSpeed Insights

Enable PSI collection to fold Google PageSpeed Insights field and lab data into every report:

```ts
export default {
  // ...
  psi: {
    enabled: true,
    strategy: 'mobile', // or 'desktop'
    // apiKey: 'your-api-key', // optional when PSI_API_KEY env var is set
  },
};
```

Supply the API key either in the config or via the `PSI_API_KEY` environment variable. The CLI requests one PSI run per unique URL using the configured strategy (default `mobile`) and merges the first successful result into `report.json`.

### Troubleshooting

- **Missing API key** – the CLI logs an error and skips PSI without failing the run.
- **PSI API errors** – network or quota issues surface as warnings but do not block report generation.
- **Slow responses** – PSI requests run sequentially with a short delay to respect rate limits; large URL sets may take longer to complete.
npm package: @forgedock/fd-fastest-plugin-psi
Description: PageSpeed Insights plugin for FD-Fastest
Author: ForgeDock
Latest version: 1.0.2

# @fd-fastest/plugin-psi

PageSpeed Insights integration for the FD-Fastest toolkit.

## Installation

```bash
pnpm add @fd-fastest/plugin-psi
```

## Setup

Create an API key for the PageSpeed Insights API via the [Google Cloud Console](https://console.cloud.google.com/apis/credentials) and enable the Pagespeed API for your project.

## Usage

```typescript
import { fetchPSI } from '@fd-fastest/plugin-psi';
import { createLogger } from '@fd-fastest/logger';

const logger = createLogger({ name: 'psi-example' });

const result = await fetchPSI({
  url: 'https://example.com',
  strategy: 'mobile',
  apiKey: 'YOUR_API_KEY',
  categories: ['performance', 'accessibility'],
});

logger.info('Performance Score', {
  score: result?.lighthouse?.performance,
});
logger.info('CrUX Metrics', {
  metrics: result?.crux?.loadingExperience.metrics,
});
```

### Batch Fetching

```typescript
import { fetchPSIBatch } from '@fd-fastest/plugin-psi';

const results = await fetchPSIBatch(
  ['https://example.com/', 'https://example.com/about'],
  {
    strategy: 'mobile',
    apiKey: 'YOUR_API_KEY',
  }
);
```

## Features

- ✅ Lighthouse scores (Performance, Accessibility, Best Practices, SEO)
- ✅ CrUX field data (real-user metrics)
- ✅ Batch fetching with rate limiting
- ✅ Error handling
- ✅ TypeScript support

## License

MIT
npm package: @forgedock/fd-fastest-reporter-json
Description: Zod schemas for FD-Fastest performance reports
Author: ForgeDock
Latest version: 1.1.0

# @fd-fastest/reporter-json

Type-safe schemas for FD-Fastest performance reports built with Zod.

## Installation

```bash
pnpm add @fd-fastest/reporter-json
```

## Usage

### Basic Validation

```typescript
import { Report, RouteMetric } from '@fd-fastest/reporter-json';
import { createLogger } from '@fd-fastest/logger';

const logger = createLogger({ name: 'report-json-example' });

// Validate a complete report
const report = Report.parse(data); // Throws if invalid

// Safe parsing (doesn't throw)
const result = Report.safeParse(data);
if (result.success) {
  logger.info('Valid report', { report: result.data });
} else {
  logger.error({ err: result.error }, 'Validation errors');
}
```

### Creating Reports

```typescript
import {
  Report,
  RouteMetric,
  REPORT_SPEC_VERSION,
} from '@fd-fastest/reporter-json';

const report: Report = {
  spec_version: REPORT_SPEC_VERSION,
  app: 'my-nextjs-app',
  git: {
    sha: 'abc123',
    branch: 'main',
  },
  run: {
    ts: new Date().toISOString(),
    device: 'desktop',
    network: 'fast-3g',
    cpuSlowdown: 4,
  },
  routes: [
    {
      path: '/',
      nav: 'cold',
      lcp_ms: 2400,
      cls: 0.05,
      inp_ms: 150,
      tbt_ms: 180,
      tti_ms: 3200,
      hydration_ms: 450,
      long_tasks: [],
      js_kb: 145,
      css_kb: 25,
      assets_top: [],
      notes: [],
    },
  ],
  budgets: {
    lcp_ms: 2500,
    cls: 0.1,
    regression_cap_pct: 10,
  },
  budgets_passed: true,
  budget_failures: [],
  psi: undefined,
};

// Validate and ensure type safety
Report.parse(report);
```

## Schemas

### RouteMetric

Performance metrics for a single route measurement.

- `path`: Route pathname
- `nav`: Navigation type (`'cold'`, `'warm'`, `'client-nav'`)
- `lcp_ms`: Largest Contentful Paint
- `cls`: Cumulative Layout Shift
- `inp_ms`: Interaction to Next Paint
- `tbt_ms`: Total Blocking Time
- `tti_ms`: Time to Interactive
- `hydration_ms`: React hydration time
- `long_tasks`: Array of blocking tasks > 50ms
- `js_kb`: JavaScript bundle size (gzipped)
- `css_kb`: CSS bundle size (gzipped)
- `assets_top`: Top 10 largest assets
- `notes`: Additional notes

### Budgets

Performance budget thresholds.

- `lcp_ms`: Maximum LCP
- `cls`: Maximum CLS
- `inp_ms`: Maximum INP
- `tbt_ms`: Maximum TBT
- `js_kb_route_max`: Maximum JS per route
- `css_kb_route_max`: Maximum CSS per route
- `regression_cap_pct`: Maximum regression % from baseline (default: 10)

### Report

Complete performance report.

- `spec_version`: Schema version
- `app`: Application name
- `git`: Git context
- `run`: Test run metadata
- `routes`: Array of route metrics
- `budgets`: Budget configuration
- `budgets_passed`: Budget check result
- `budget_failures`: Failed checks
- `psi`: Optional PageSpeed Insights data

## License

MIT
npm package: @forgedock/fd-fastest-reporter-md
Description: Markdown report generator for FD-Fastest
Author: ForgeDock
Latest version: 1.0.0

# @fd-fastest/reporter-md

Markdown report generator for FD-Fastest performance reports. Transforms the JSON report produced by `@fd-fastest/reporter-json` into human-readable Markdown for pull requests, dashboards, or release notes.

## Usage

```ts
import {
  generateMarkdownReport,
  generateCompactSummary,
} from '@fd-fastest/reporter-md';
import type { Report } from '@fd-fastest/reporter-json';

declare const report: Report;

const fullReport = generateMarkdownReport(report);
const compactSummary = generateCompactSummary(report);
```

Run `pnpm build` to produce the compiled output and `pnpm test` to execute the Vitest suite.
npm package: @forgedock/fd-fastest-tracer-next
Description: Server-side fetch tracing for Next.js
Author: ForgeDock
Latest version: 1.0.0

# @fd-fastest/tracer-next

Server-side fetch tracing for Next.js applications.

## Installation

```bash
pnpm add @fd-fastest/tracer-next
```

## Usage

### 1. Add instrumentation

Create `instrumentation.ts` in your Next.js root:

```typescript
export { register } from '@fd-fastest/tracer-next/instrumentation';
```

### 2. Create spans endpoint

Create `app/__fdfast/spans/route.ts`:

```typescript
export { GET } from '@fd-fastest/tracer-next/route';
```

### 3. Access spans

Visit `http://localhost:3000/__fdfast/spans` to see fetch traces.

## Example Response

```json
{
  "spans": [
    {
      "t": "fetch",
      "url": "https://api.example.com/data",
      "method": "GET",
      "status": 200,
      "dur": 45.3,
      "ts": 1705324800000
    }
  ],
  "count": 1,
  "timestamp": 1705324800500
}
```

## Features

- ✅ Automatic fetch patching
- ✅ Timing information
- ✅ Status codes
- ✅ Buffer size limiting (2000 spans)
- ✅ Zero configuration

## License

MIT
npm package: @forgefoundry/anvil
Description: Anvil — repo-agnostic AI code assistant CLI. Index locally, chat in terminal, and apply diffs safely.
Latest version: 0.1.0

# @forge/anvil — AI code assistant CLI

Anvil is a developer-first CLI that indexes your repo locally, lets you **chat in the terminal**, and proposes **unified diffs** you can review and apply.

## Install

```bash
npm i -g @forge/anvil
# or
npx @forge/anvil@latest chat
```

## Quick start

```bash
cd /path/to/your/repo
anvil init          # creates .anvil/ workspace and config
anvil index         # builds a local search index
anvil chat          # interactive chat about your code
anvil search auth   # ad-hoc search
anvil diff          # show last proposed patch
anvil apply         # apply staged patch to the working tree
```

> OpenAI is optional. If you set `OPENAI_API_KEY`, Anvil can phrase richer answers and propose diffs. Without it, chat uses local retrieval and deterministic summaries.

## Config

Per-repo config lives in `.anvilrc.json` and `.anvil/config/`:

```json
{
  "provider": "openai",
  "model": "gpt-4o-mini",
  "embeddingModel": "text-embedding-3-large",
  "ignore": [".git", "node_modules", "dist", "build"],
  "redact": ["AWS_SECRET", "PRIVATE_KEY", "API_KEY"],
  "maxContextBytes": 180000
}
```

## Safety

- Respects `.gitignore`
- Skips binaries by extension and size
- Never writes changes without `anvil apply`
- Stores everything under `.anvil/`

## License

MIT
npm package: @forgeframe/memory
Description: Persistent semantic memory for MCP — local-first, weighted, decaying
Latest version: 0.1.1

# @forgeframe/memory

Persistent semantic memory with weighted retrieval. Local-first. SQLite-backed.

## What it does

Stores memories in a local SQLite database with FTS5 full-text search. Memories have strength scores that decay over time -- frequently accessed memories persist, neglected ones fade. Sessions group related memories and track lifecycle.

## Install

```bash
npm install @forgeframe/memory
```

## Usage

```typescript
import { MemoryStore, MemoryRetriever } from '@forgeframe/memory';

const store = new MemoryStore({ dbPath: './memory.db' });
const retriever = new MemoryRetriever(store);

// Create a memory
store.create({ content: 'User prefers dark mode', tags: ['preference'] });

// Search
const results = retriever.query({ text: 'dark mode', limit: 5 });

// Sessions
const session = store.startSession();
store.endSession(session.id);
```

## Features

- SQLite + FTS5 full-text search
- Weighted retrieval (recency + access frequency)
- Configurable strength decay
- Session-scoped and cross-session queries
- Extension point for embedding-based semantic search
- Zero cloud dependency

## License

MIT
npm package: @forgegraph/cli-darwin-arm64
Description: ForgeGraph CLI binary for macOS ARM64 (Apple Silicon)
Latest version: 0.3.1

# @forgegraph/cli-darwin-arm64

Platform-specific binary for the ForgeGraph CLI on macOS ARM64 (Apple Silicon).

**Do not install this package directly.** Install `@forgegraph/cli` instead:

```sh
npm install -g @forgegraph/cli
```

This package is automatically selected as an optional dependency when installing on a compatible platform.
npm package: @forgegraph/cli-darwin-x64
Description: ForgeGraph CLI binary for macOS x64 (Intel)
Latest version: 0.3.1

# @forgegraph/cli-darwin-x64

Platform-specific binary for the ForgeGraph CLI on macOS x64 (Intel).

**Do not install this package directly.** Install `@forgegraph/cli` instead:

```sh
npm install -g @forgegraph/cli
```

This package is automatically selected as an optional dependency when installing on a compatible platform.
npm package: @forgegraph/cli-linux-arm64
Description: ForgeGraph CLI binary for Linux ARM64
Latest version: 0.3.1

# @forgegraph/cli-linux-arm64

Platform-specific binary for the ForgeGraph CLI on Linux ARM64.

**Do not install this package directly.** Install `@forgegraph/cli` instead:

```sh
npm install -g @forgegraph/cli
```

This package is automatically selected as an optional dependency when installing on a compatible platform.
npm package: @forgehive/forge-cli
Description: TypeScript CLI application
Latest version: 0.3.18

# @mono/cli

A TypeScript CLI application for the Mono project.

## Installation

```bash
# Install dependencies
npm install

# Build the CLI
npm run build
```

## Usage

```bash
# Run the CLI
npm start

# Or run in development mode
npm run dev

# Run a specific command
npm start -- hello
```

## Available Commands

- `hello`: Displays a greeting message

## Development

```bash
# Run tests
npm test

# Lint code
npm run lint
```
npm package: @forgehouse/mcp-server
Description: MCP server for ForgeHouse AI mentors — connect your AI agent to world-class business mentors
Latest version: 0.1.0

# @forgehouse/mcp-server

MCP server for [ForgeHouse](https://forgehouse.io) AI mentors. Connect your agent (OpenClaw, Claude Code, Cursor, etc.) directly to world-class mentors.

## Setup

1. Subscribe at [forgehouse.io/pricing](https://forgehouse.io/pricing)
2. Get your API key from your dashboard
3. Install: `npm install -g @forgehouse/mcp-server`

## Configuration

### OpenClaw / Claude Code

Add to your MCP config:

```json
{
  "mcpServers": {
    "forgehouse": {
      "command": "forgehouse-mcp",
      "env": {
        "FORGEHOUSE_API_KEY": "fh_your_api_key_here"
      }
    }
  }
}
```

### Cursor

Add to `.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "forgehouse": {
      "command": "npx",
      "args": ["@forgehouse/mcp-server"],
      "env": {
        "FORGEHOUSE_API_KEY": "fh_your_api_key_here"
      }
    }
  }
}
```

## Tools

### `list_mentors`
List all available ForgeHouse mentors.

### `ask_mentor`
Ask a mentor a question. Supports conversation history for multi-turn interactions.

Parameters:
- `mentor` (string): Mentor slug, e.g. `"colin-chapman"`
- `message` (string): Your question
- `conversation` (array, optional): Previous messages for context

## Example

```
> ask_mentor("colin-chapman", "I'm doing 400 cold emails a week with zero responses. What am I doing wrong?")
```

## Available Mentors

- **Colin Chapman** (`colin-chapman`) — 26 years in GTM & outbound sales. Specializes in sales strategy, pipeline building, and converting cold prospects.

More mentors coming soon.
npm package: @forgehouseio/mcp-server
Description: MCP server for ForgeHouse expert knowledge modules. Connect your AI agent to vetted domain experts.
Author: ForgeHouse
Latest version: 0.1.0
Deprecated: Moved to @forgehouse/mcp-server

# @forgehouseio/mcp-server

Connect your AI agent to [ForgeHouse](https://forgehouse.io) expert knowledge modules via MCP (Model Context Protocol).

Make your agent an expert — without reading a single book.

## What is this?

ForgeHouse extracts expertise from vetted domain experts and makes it available as agent-accessible knowledge modules. This MCP server lets any MCP-compatible agent (OpenClaw, Claude Code, Cursor, etc.) talk to ForgeHouse experts directly.

**Currently available:**
- **Colin Chapman** — 26 years of GTM & outbound sales expertise

## Setup

### 1. Get your API key

Sign up at [forgehouse.io](https://forgehouse.io), subscribe, and grab your API key from your [account page](https://forgehouse.io/account).

### 2. Configure your agent

Add to your MCP config (e.g. `mcp.json`, OpenClaw config, or Claude Desktop settings):

```json
{
  "mcpServers": {
    "forgehouse": {
      "command": "npx",
      "args": ["-y", "@forgehouseio/mcp-server"],
      "env": {
        "FORGEHOUSE_API_KEY": "fh_your_api_key_here"
      }
    }
  }
}
```

That's it. Your agent now has access to ForgeHouse experts.

## Tools

### `list_mentors`
Lists available expert modules.

### `ask_mentor`
Ask an expert a question. Maintains conversation context across calls automatically.

Parameters:
- `mentor` (string, required) — Expert ID (e.g. `"colin-chapman"`)
- `message` (string, required) — Your question
- `new_conversation` (boolean, optional) — Start a fresh thread

## Environment Variables

| Variable | Required | Description |
|---|---|---|
| `FORGEHOUSE_API_KEY` | Yes | Your ForgeHouse API key (`fh_...`) |
| `FORGEHOUSE_API_URL` | No | Custom API endpoint (default: `https://forgehouse.io/api/v1`) |

## Example

Once configured, your agent can:

```
You: Ask Colin how to structure a cold outbound sequence for a B2B SaaS product.

Agent: [calls ask_mentor with mentor="colin-chapman"]

Colin: Here's how I'd structure it...
```

Your agent gets domain expertise. You do nothing.

## License

MIT
npm package: @forgekit/cli
Description: Modular full-stack project scaffolding tool
Author: ForgeKit Contributors
Latest version: 1.0.10

# ForgeKit

ForgeKit is a modular scaffolding tool that helps you spin up full‑stack projects with your choice of frontend, backend and UI frameworks. It creates the initial directory structure, initializes Git and installs required dependencies so you can start coding right away.

## Prerequisites

- Node.js (version 18 or later recommended)
- npm or yarn
- Git installed and available in your PATH

## Example Usage

Install the package globally and run the CLI:

```bash
npm install -g @forgekit/cli
forge
```

Running `forge` will prompt you step‑by‑step for a frontend, UI library, backend
and optional database. Choices are filtered so only compatible combinations are
shown. The project is created in the directory where you executed the command
and when scaffolding finishes you will be dropped into a shell inside the new
project folder.

The tool can also be configured programmatically. Example configuration from the project plan:

```ts
{
  projectName: "acme-site",
  frontend: "react-vite",
  backend: "express",
  ui: "tailwind",
  targetDir: "./acme-site"
}
```

You can also use `npx` without installing globally:

```bash
npx @forgekit/cli
```
This behaves the same as the global install, prompting for details and placing
you in the newly created project directory when finished.

If the `forge` command is not found after a global install, ensure your npm
global bin directory is in your `PATH`.
You can typically add it with:

```bash
$env:Path += ";$(npm bin -g)"
```

You can verify your environment at any time with the built in doctor command:

```bash
forge --doctor
```

## `forge login`

Run this command to authenticate the CLI with your ForgeKit account. Your web
browser will open to complete the login flow and the received token will be
stored in `~/.forgekit/config.json`.

Example config file:

```json
{
  "token": "USER_JWT"
}
```

## `forge deploy`

Run this command to publish your project. It will:

- Build the project.
- Bundle your build output into `bundle.tar.gz` (defaults to `dist/`, overridable with `--build-dir`).
- Upload the archive to ForgeKit hosting.

If you are not logged in, the command will open a browser and prompt you to
authenticate before deploying.

If a `forgekit.json` file exists it will be used to auto-detect the build directory based on the scaffolded stack.
The deploy endpoint can be customized with the `FORGEKIT_DEPLOY_URL` environment variable.

Example:

```bash
forge deploy --build-dir .next
```

## Purpose

ForgeKit aims to streamline bootstrapping modern JavaScript projects by providing a collection of ready‑to‑use stacks with minimal setup hassle.


## Development

Run tests with:

```bash
npm test
```

To update the stack documentation after modifying the available options run:


```bash
npm run generate-stack-docs
```

This will regenerate `STACKS.md` based on the registry files.

There is currently no formal CONTRIBUTING guide, but pull requests and issues are welcome.
npm package: @forgelab/arena
Description: A javascript memory pool based on `Float32Array` that is very easy to use and extremely fast, with minimal overhead for each allocation or deletion and no garbage collection (GC) overhead.
Author: Vincent Wang
Latest version: 1.0.0

# Arena

![NPM Version](https://img.shields.io/npm/v/%40forgelab%2Farena)

A javascript memory pool based on `Float32Array` that is very easy to use and extremely fast, with minimal overhead for each allocation or deletion and no garbage collection (GC) overhead.

## Example


```ts
import { arena } from '@forgelab/arena';

const memory = arena();
const p1 = memory.create([1, 2, 3]);
p1.update([4, 5]);
p1.update([6, 7, 8, 9]);
const p2 = p1.clone();
console.log(p2.value);
```
npm package: @forgemcp/keepa
Description: Fetch Amazon product history (Price, Sales Rank) via Keepa API. Use for checking current prices, trends, and analyzing ASIN data.
Author: ForgeMCP
Latest version: 0.0.1

---
name: keepa-api
description: Fetch Amazon product history (Price, Sales Rank) via Keepa API. Use for checking current prices, trends, and analyzing ASIN data.
---

# Keepa API Skill

This skill retrieves product data from Amazon via the Keepa API using **Bun**. It provides current pricing, sales rank, and a history of recent changes.

## Usage

To fetch product details for a given ASIN:

```bash
bun run cli.ts product <ASIN>
```

To fetch best sellers for a category:

```bash
bun run cli.ts bestsellers <CATEGORY>
```

## Features
- **Native Bun Implementation**: Fast startup, built-in TypeScript support.
- **Token Handling**: Logs remaining tokens and refill time to stderr.
- **History Decoding**: Automatically converts Keepa's compressed CSV time format to ISO dates.

## Output

The script outputs a JSON object containing:
-   **Meta**: Token usage info (`tokensLeft`, `refillIn`).
-   **Product Info**: Title, Brand, Manufacturer.
-   **Current Stats**: Object `{ amazon, new, used, salesRank }` with latest values in cents (e.g., 1999 = $19.99).
-   **History**: Arrays of recent changes for Amazon Price, New Price, and Sales Rank.
    -   `amazon_price`: Sold by Amazon.
    -   `new_price`: 3rd Party New.
    -   `sales_rank`: Best Sellers Rank.

## Examples

**Fetch data for an ASIN:**
```bash
bun run cli.ts B0D8T9CQVV
```

**Run Tests:**
```bash
bun test
```
npm package: @forgen/remark-remote-code
Description: 📝 Populate code blocks from remote files
Author: Alexandre Hanot
Latest version: 1.0.2

# `@forgen/remark-remote-code`

🔗 Enhance your Markdown files by dynamically importing code blocks from remote sources.

[![npm version](https://badge.fury.io/js/%40forgen%2Fremark-remote-code.svg)](https://badge.fury.io/js/%40forgen%2Fremark-remote-code)

**Important: As of version 1.0.0, `@forgen/remark-remote-code` is an [ESM-only module](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c). It requires Node.js version 12 or higher and must be used with `import` rather than `require`.**

## Installation

Use npm to install the package:

```sh
npm install -D @forgen/remark-remote-code
```

## Setup

Import the plugin using named export; there is no default export:

```js
import { remoteCode } from '@forgen/remark-remote-code';
```

For detailed instructions on using plugins, refer to the [official documentation](https://github.com/remarkjs/remark/blob/master/doc/plugins.md#using-plugins).

`@forgen/remark-remote-code` is compatible with various libraries like `remark` in [MDX](https://mdxjs.com/advanced/plugins#using-remark-and-rehype-plugins), [Gatsby's `gatsby-plugin-mdx`](https://www.gatsbyjs.org/docs/mdx/plugins/#remark-plugins), and [Storybook docs](https://github.com/storybookjs/storybook/tree/master/addons/docs#manual-configuration).

## Usage

Convert a simple reference in your Markdown:

````md
```js url=https://.../example-script.js
```
````

Into a full code block populated with content:

````md
```js url=https://.../example-script.js
// Content of example-script.js
```
````

The file path is relative to the markdown file. Use `<rootDir>` to refer to a custom root directory defined in the [options](#options):

````md
```js url=<rootDir>/script-in-root.js
```
````

Specify specific lines or ranges to include:

````md
Only line 3:
```js url=https://.../example-script.js#L3
```

From line 3 to line 6:
```js url=https://.../example-script.js#L3-L6
```

From line 3 to the end of the file:
```js url=https://.../example-script.js#L3-
```
````

Escape file paths with spaces:

````md
```js url=https://...//file\ with\ spaces.js
```
````

## Options

- `rootDir: string`: Customize what `<rootDir>` points to.
- `preserveTrailingNewline: boolean`: Keep the trailing newline in imported code. Defaults to `false`.
- `removeRedundantIndentations: boolean`: Trim unnecessary indentations in the imported code.
- `allowImportingFromOutside: boolean`: Allow file imports from outside the specified `rootDir`. Disabled by default for security.

## Integration with Gatsby

Available as a Gatsby remark plugin through the `/gatsby` endpoint:

```js
{
  resolve: '@forgen/remark-remote-code/gatsby',
  options: {/* ... */}
}
```

## Testing

Install dependencies with `npm install`. Run tests using `npm test`.

## License

Forgen

[MIT License](LICENSE)

---

`@forgen/remark-remote-code` is a versatile tool for enhancing documentation and instructional content, ensuring code examples are always up-to-date and relevant.
npm package: @forgerock/openam-agent
Description: ForgeRock AM Policy Agent for Node.js
Author: Zoltan Tarcsay
Latest version: 5.1.5

# node-openam-agent [![Build Status](https://travis-ci.org/ForgeRock/node-openam-agent.svg?branch=master)](https://travis-ci.org/ForgeRock/node-openam-agent) [![npm version](https://badge.fury.io/js/%40forgerock%2Fopenam-agent.svg)](http://badge.fury.io/js/%40forgerock%2Fopenam-agent)

> [OpenAM](https://backstage.forgerock.com/docs/am/6/quick-start-guide) Policy Agent for [express](http://expressjs.com/) applications.

## Documentation

You can find howtos and API docs in the [wiki](https://github.com/ForgeRock/node-openam-agent/wiki).

## Installation

```
npm i @forgerock/openam-agent
```

## TypeDoc

Run `npm run docs` to build the API docs under /docs

## Examples

Check out the [demo app](https://github.com/ForgeRock/node-openam-agent-demo) for some code examples.

## Contributing

Contributions and suggestions are most welcome. Please open an issue or submit a pull request.

## License

[MIT](https://raw.githubusercontent.com/ForgeRock/node-openam-agent/master/LICENSE.md)

## DISCLAIMER

The sample code described herein is provided on an "as is" basis, without warranty of any kind, to the fullest extent permitted by law. ForgeRock does not warrant or guarantee the individual success developers may have in implementing the sample code on their development platforms or in production configurations.

ForgeRock does not warrant, guarantee or make any representations regarding the use, results of use, accuracy, timeliness or completeness of any data or information relating to the sample code. ForgeRock disclaims all warranties, expressed or implied, and in particular, disclaims all warranties of merchantability, and warranties related to the code, or any service or software related thereto.

ForgeRock shall not be liable for any direct, indirect or consequential damages or costs of any type arising out of any action taken by you or others related to the sample code.
npm package: @forgerock/openam-agent-cache
Description: Abstract cache for the OpenAM Policy Agent for NodeJS
Author: Zoltan Tarcsay
Latest version: 2.0.0

# openam-agent-cache
Abstract cache for the OpenAM Policy Agent for NodeJS

Implement this class to use your own cache with any backed with the
[node-openam-policy-agent](https://github.com/ForgeRock/node-openam-agent)

# API Docs

<a name="Cache"></a>

## *Cache*
**Kind**: global abstract class  

* *[Cache](#Cache)*
    * *[new Cache()](#new_Cache_new)*
    * *[.get(key)](#Cache+get) ⇒ <code>Promise</code>*
    * *[.put(key, value)](#Cache+put) ⇒ <code>Promise</code>*
    * *[.remove(key)](#Cache+remove) ⇒ <code>Promise</code>*
    * *[.quit()](#Cache+quit) ⇒ <code>Promise</code>*

<a name="new_Cache_new"></a>

### *new Cache()*
Abstract Cache class

<a name="Cache+get"></a>

### *cache.get(key) ⇒ <code>Promise</code>*
Get a single cached item
If the entry is not found, reject

**Kind**: instance method of <code>[Cache](#Cache)</code>  

| Param | Type |
| --- | --- |
| key | <code>string</code> | 

<a name="Cache+put"></a>

### *cache.put(key, value) ⇒ <code>Promise</code>*
Store a single cached item (overwrites existing)

**Kind**: instance method of <code>[Cache](#Cache)</code>  

| Param | Type |
| --- | --- |
| key | <code>string</code> | 
| value | <code>\*</code> | 

<a name="Cache+remove"></a>

### *cache.remove(key) ⇒ <code>Promise</code>*
Remove a single cached item

**Kind**: instance method of <code>[Cache](#Cache)</code>  

| Param | Type |
| --- | --- |
| key | <code>string</code> | 

<a name="Cache+quit"></a>

### *cache.quit() ⇒ <code>Promise</code>*
Closes the client connection

**Kind**: instance method of <code>[Cache](#Cache)</code>  

## DISCLAIMER

The sample code described herein is provided on an "as is" basis, without warranty of any kind, to the fullest extent permitted by law. ForgeRock does not warrant or guarantee the individual success developers may have in implementing the sample code on their development platforms or in production configurations.

ForgeRock does not warrant, guarantee or make any representations regarding the use, results of use, accuracy, timeliness or completeness of any data or information relating to the sample code. ForgeRock disclaims all warranties, expressed or implied, and in particular, disclaims all warranties of merchantability, and warranties related to the code, or any service or software related thereto.

ForgeRock shall not be liable for any direct, indirect or consequential damages or costs of any type arising out of any action taken by you or others related to the sample code.