open-index/open-npm huggingface dataset:
npm package: @recallnet/docs-governance-policy
Description: Shared policy loader and path resolution helpers for docs governance remark plugins.
Latest version: 0.3.1

# @recallnet/docs-governance-policy

Shared helpers for docs governance rules:

- load `docs/docs-policy.json`
- match policy globs
- resolve review-policy defaults
- compute reachability roots and orphan allowlists
- resolve taxonomy rules and exclusions
npm package: @recallnet/docs-governance-preset
Description: Preset and bootstrap CLI for Recall docs governance in remark-based repos.
Latest version: 0.3.4

# @recallnet/docs-governance-preset

One-package bootstrap for Recall docs governance.

It wires the existing remark ecosystem plus Recall's governance rules:

- `remark-frontmatter`
- `remark-lint-frontmatter-schema`
- `remark-validate-links`
- `@recallnet/remark-lint-docs-taxonomy`
- `@recallnet/remark-lint-docs-freshness`
- `@recallnet/remark-lint-docs-reachability`

## Install

```bash
pnpm add -D @recallnet/docs-governance-preset
pnpm exec recall-docs-governance init --profile repo-docs
pnpm exec recall-docs-governance populate --profile repo-docs
```

Then run:

```bash
pnpm docs:lint
```

`init` creates the canonical structure and config.

`populate` is the deterministic first-pass content generator. It scans repo facts such as
`package.json`, workspace manifests, CI workflows, local hooks, `README.md`, and `AGENTS.md`, then
writes a bounded set of canonical docs and links them into `docs/INDEX.md`.
npm package: @recallnet/remark-lint-docs-freshness
Description: Remark plugin that checks docs reviewed dates against repo policy.
Latest version: 0.2.7

# @recallnet/remark-lint-docs-freshness

Checks Markdown frontmatter `reviewed` dates against policy-defined `max_age_days`.

## Install

```bash
npm install -D remark remark-frontmatter @recallnet/remark-lint-docs-freshness
```

## Use

Use with `remark-frontmatter` so YAML frontmatter is available to the rule:

```js
import { remark } from "remark";
import remarkFrontmatter from "remark-frontmatter";
import remarkLintDocsFreshness from "@recallnet/remark-lint-docs-freshness";

await remark()
  .use(remarkFrontmatter)
  .use(remarkLintDocsFreshness, {
    cwd: process.cwd(),
    policyPath: "./docs/docs-policy.json",
  })
  .process({
    path: "docs/architecture/cache.md",
    value: `---
review_policy: periodic-7
reviewed: 2026-03-01
---

# Cache`,
  });
```

## What It Checks

- only files that match `in_scope_paths` in `docs/docs-policy.json`
- only docs using periodic review policies
- frontmatter `reviewed` values in `YYYY-MM-DD` format
- whether `reviewed` is older than the policy's `max_age_days`

The rule reports messages such as:

```text
Document is stale: reviewed=2026-03-01 age_days=18 max_age_days=7.
```

## Options

- `cwd`
  Repository root used to resolve the docs policy and the current file path.
- `policyPath`
  Path to the docs policy file relative to `cwd`.
  Defaults to `docs/docs-policy.json`.
- `today`
  Override the current date as `YYYY-MM-DD`.
  Useful for deterministic tests.

## Notes

- Docs with non-periodic policies such as `historical` are ignored.
- If frontmatter is missing or unreadable for an in-scope file, the rule reports that freshness could not be checked.
- Frontmatter parsing uses `vfile-matter`, which is the unified-recommended way to expose YAML metadata on `file.data.matter`.
- This package is intended for docs-governance setups that keep freshness policy in repo config rather than hardcoding date thresholds in lint config.
npm package: @recallnet/remark-lint-docs-reachability
Description: Remark plugin that flags markdown docs not reachable from policy roots.
Latest version: 0.2.7

# @recallnet/remark-lint-docs-reachability

Flags in-scope Markdown documents that are not reachable from policy-defined roots.

## Install

```bash
npm install -D remark @recallnet/remark-lint-docs-reachability
```

## Use

```js
import { remark } from "remark";
import remarkLintDocsReachability from "@recallnet/remark-lint-docs-reachability";

await remark()
  .use(remarkLintDocsReachability, {
    cwd: process.cwd(),
    policyPath: "./docs/docs-policy.json",
  })
  .process({
    path: "docs/architecture/cache.md",
    value: "# Cache\n",
  });
```

## What It Checks

- all in-scope Markdown files matched by `in_scope_paths`
- graph roots declared by docs policy
- repo-local Markdown links between in-scope docs
- policy allowlists for roots, legacy docs, and orphan exclusions

The rule reports messages such as:

```text
Document is not reachable from policy roots: docs/architecture/orphan.md
```

## Options

- `cwd`
  Repository root used to resolve the docs policy and scan in-scope docs.
- `policyPath`
  Path to the docs policy file relative to `cwd`.
  Defaults to `docs/docs-policy.json`.

## Notes

- External links are ignored. Reachability is only about repo-owned docs.
- Missing local link targets are ignored here; link correctness belongs to `remark-validate-links`.
- Broken symlinks outside the docs graph are skipped instead of crashing the scan.

This package intentionally complements:

- `remark-validate-links` for link validity
- `remark-lint-frontmatter-schema` for frontmatter schema checks
- `@recallnet/remark-lint-docs-taxonomy` for path and filename enforcement
npm package: @recallnet/remark-lint-docs-taxonomy
Description: Remark plugin that enforces policy-driven docs taxonomy paths and filenames.
Latest version: 0.2.3

# @recallnet/remark-lint-docs-taxonomy

Flags Markdown docs whose `doc_type` does not match the policy-defined directory or filename rules.

Use with `remark-frontmatter` and a repo policy that includes a `taxonomy` section.
npm package: @recap.dev/babel-plugin
Description: Babel plugin to set up function-level tracing for recap.dev, an open-source cloud observability and tracing solution for modern JavaScript backends.
Author: Arseny Yankovski
Latest version: 1.0.3

<p align="center">
  <a href="https://recap.dev" target="_blank" align="center">
    <img src="https://raw.githubusercontent.com/infinite-cat/recap.dev-server/master/logo.svg" width="300">
  </a>
  <br />
</p>

[![npm downloads](https://img.shields.io/npm/dw/@recap.dev/babel-plugin)](https://www.npmjs.com/package/@recap.dev/babel-plugin) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/infinite-cat/recap.dev-babel-plugin/blob/master/LICENSE) [![recap.dev Docker Hub](https://img.shields.io/badge/Docker%20Hub-recapdev%2Fserver-informational "recap.dev Docker Hub")](https://hub.docker.com/repository/docker/recapdev/server)

[Website](https://recap.dev) | [Documentation](https://recap.dev/docs/) | [Demo](https://demo.recap.dev/) | [Report a Bug](https://github.com/infinite-cat/recap.dev-server/issues/new)


recap.dev is an open-source cloud observability and tracing solution for modern JavaScript backends. Our goal is to make it easier for everyone to find sources of errors, find bottlenecks, and improve overall developer quality of life.

* **Detailed per-endpoint tracing:** recap.dev builds a timeline of what is going on during endpoint handler execution.
  That includes database and external calls as well as timings of individual functions simplifying debugging and performance optimization.
  recap.dev also provides an overview of the system and tries to give you as much useful information as possible.

* **Easy-to-setup**: recap.dev server is easy to start with a couple of commands. It is shipped as a Docker container, so it can be
  started wherever you host your applications. We try to integrate with as many tools as possible to provide an easy way of tracing your application with minimal to no code changes.

* **Open-source**: We believe that development tools should be open-source. Especially tools that might gather or contain sensitive data.
  Hosting these tools on your servers is important so that the sensitive data never leaves your organization. It is also important to know what precisely these tools do with your data.

[Learn how to start with recap.dev](https://recap.dev/docs/)

## recap.dev-babel-plugin

**recap.dev-babel-plugin** repository is a babel plugin that automatically wraps your functions and methods to provide function-level tracing.
npm package: @recap.dev/client
Description: Client library for recap.dev, an open-source cloud observability and tracing solution for modern JavaScript backends.
Author: Arseny Yankovsky
Latest version: 4.4.3

<p align="center">
  <a href="https://recap.dev" target="_blank" align="center">
    <img src=".github/assets/logo.svg" width="300">
  </a>
  <br />
</p>

[![npm downloads](https://img.shields.io/npm/dw/@recap.dev/client)](https://www.npmjs.com/package/@recap.dev/client) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/infinite-cat/recap.dev-client/blob/master/LICENSE) [![recap.dev Docker Hub](https://img.shields.io/badge/Docker%20Hub-recapdev%2Fserver-informational "recap.dev Docker Hub")](https://hub.docker.com/repository/docker/recapdev/server)

[Website](https://recap.dev) | [Documentation](https://recap.dev/docs/) | [Demo](https://demo.recap.dev/) | [Report a Bug](https://github.com/infinite-cat/recap.dev-server/issues/new)


recap.dev is an open-source cloud observability and tracing solution for modern JavaScript backends. Our goal is to make it easier for everyone to find sources of errors, find bottlenecks, and improve overall developer quality of life.

* **Detailed per-endpoint tracing:** recap.dev builds a timeline of what is going on during endpoint handler execution.
  That includes database and external calls as well as timings of individual functions simplifying debugging and performance optimization.
  recap.dev also provides an overview of the system and tries to give you as much useful information as possible.

* **Easy-to-setup**: recap.dev server is easy to start with a couple of commands. It is shipped as a Docker container, so it can be
  started wherever you host your applications. We try to integrate with as many tools as possible to provide an easy way of tracing your application with minimal to no code changes.

* **Open-source**: We believe that development tools should be open-source. Especially tools that might gather or contain sensitive data.
  Hosting these tools on your servers is important so that the sensitive data never leaves your organization. It is also important to know what precisely these tools do with your data.

[Learn how to start with recap.dev](https://recap.dev/docs/)

## recap.dev-client

**recap.dev-client** repository contains source-code for a client-side Node.js tracing library. 

[Learn how to use this library to trace your application with recap.dev](https://recap.dev/docs/tracing)
npm package: @recap.dev/serverless-plugin
Description: Serverless Framework tracing plugin for recap.dev, an open-source cloud observability and tracing solution for modern JavaScript backends.
Author: Arseny Yankovsky
Latest version: 1.1.2

<p align="center">
  <a href="https://recap.dev" target="_blank" align="center">
    <img src="https://raw.githubusercontent.com/infinite-cat/recap.dev-server/master/logo.svg" width="300">
  </a>
  <br />
</p>

[![npm downloads](https://img.shields.io/npm/dw/@recap.dev/serverless-plugin)](https://www.npmjs.com/package/@recap.dev/serverless-plugin) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/infinite-cat/recap.dev-serverless-plugin/blob/master/LICENSE) [![recap.dev Docker Hub](https://img.shields.io/badge/Docker%20Hub-recapdev%2Fserver-informational "recap.dev Docker Hub")](https://hub.docker.com/repository/docker/recapdev/server)

[Website](https://recap.dev) | [Documentation](https://recap.dev/docs/) | [Demo](https://demo.recap.dev/) | [Report a Bug](https://github.com/infinite-cat/recap.dev-server/issues/new)


recap.dev is an open-source cloud observability and tracing solution for modern JavaScript backends. Our goal is to make it easier for everyone to find sources of errors, find bottlenecks, and improve overall developer quality of life.

* **Detailed per-endpoint tracing:** recap.dev builds a timeline of what is going on during endpoint handler execution.
  That includes database and external calls as well as timings of individual functions simplifying debugging and performance optimization.
  recap.dev also provides an overview of the system and tries to give you as much useful information as possible.

* **Easy-to-setup**: recap.dev server is easy to start with a couple of commands. It is shipped as a Docker container, so it can be
  started wherever you host your applications. We try to integrate with as many tools as possible to provide an easy way of tracing your application with minimal to no code changes.

* **Open-source**: We believe that development tools should be open-source. Especially tools that might gather or contain sensitive data.
  Hosting these tools on your servers is important so that the sensitive data never leaves your organization. It is also important to know what precisely these tools do with your data.

[Learn how to start with recap.dev](https://recap.dev/docs/)

## recap.dev-serverless-plugin

**recap.dev-serverless-plugin** repository is a Serverless Framework plugin that automatically wraps your handlers and sends the tracing data to the recap.dev server.

[Learn how to use this plugin to integrate your Serverless application with recap.dev](https://recap.dev/docs/tracing#serverless-framework)
npm package: @recap.dev/ts-transformer
Description: TypeScript transformer to set up function-level tracing for recap.dev, an open-source cloud observability and tracing solution for modern JavaScript backends.
Author: Arseny Yankovski
Latest version: 1.0.1

<p align="center">
  <a href="https://recap.dev" target="_blank" align="center">
    <img src="https://raw.githubusercontent.com/infinite-cat/recap.dev-server/master/logo.svg" width="300">
  </a>
  <br />
</p>

[![npm downloads](https://img.shields.io/npm/dw/@recap.dev/ts-transformer)](https://www.npmjs.com/package/@recap.dev/ts-transformer) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/infinite-cat/recap.dev-ts-transformer/blob/master/LICENSE) [![recap.dev Docker Hub](https://img.shields.io/badge/Docker%20Hub-recapdev%2Fserver-informational "recap.dev Docker Hub")](https://hub.docker.com/repository/docker/recapdev/server)

[Website](https://recap.dev) | [Documentation](https://recap.dev/docs/) | [Demo](https://demo.recap.dev/) | [Report a Bug](https://github.com/infinite-cat/recap.dev-server/issues/new)


recap.dev is an open-source cloud observability and tracing solution for modern JavaScript backends. Our goal is to make it easier for everyone to find sources of errors, find bottlenecks, and improve overall developer quality of life.

* **Detailed per-endpoint tracing:** recap.dev builds a timeline of what is going on during endpoint handler execution.
  That includes database and external calls as well as timings of individual functions simplifying debugging and performance optimization.
  recap.dev also provides an overview of the system and tries to give you as much useful information as possible.

* **Easy-to-setup**: recap.dev server is easy to start with a couple of commands. It is shipped as a Docker container, so it can be
  started wherever you host your applications. We try to integrate with as many tools as possible to provide an easy way of tracing your application with minimal to no code changes.

* **Open-source**: We believe that development tools should be open-source. Especially tools that might gather or contain sensitive data.
  Hosting these tools on your servers is important so that the sensitive data never leaves your organization. It is also important to know what precisely these tools do with your data.

[Learn how to start with recap.dev](https://recap.dev/docs/)

## recap.dev-ts-transformer

**recap.dev-ts-transformer** repository is a TypeScript transformer that automatically wraps your functions and methods to provide function-level tracing.
npm package: @recart/nacelle-nuxt-module
Description: Recart integration for Nacelle
Author: Recart
Latest version: 0.1.1

# Recart integration for Nacelle

Recart works out of the box on normal Shopify storefronts. 

However, if you have a Nacelle site, you need to install this Nuxt module to make Recart work.

## Requirements

- A Nacelle project set up locally. See https://docs.getnacelle.com for getting started.
- Shopify store backend.
- [Recart](https://recart.com/) installed on your Shopify store.

## Usage

1. **Install our package.**

    ```
    npm install @recart/nacelle-nuxt-module
    ```

2. **Add the module to your Nacelle app.**

    Open `nuxt.config.js` and add `@recart/nacelle-nuxt-module` to the `modules` array, along with your Recart Site ID.
    
    It should look like this:

    ```
    modules: [
      '@nuxtjs/pwa',
      '@nuxtjs/dotenv',
      '@nacelle/nacelle-nuxt-module',
      '@nuxtjs/sitemap',
      ['@recart/nacelle-nuxt-module', { recartSiteId: '5abcdefgh000000000000000' }]
    ],
    ```

    You can find your Site ID on the Recart dashboard: [app.recart.com/settings/me](https://app.recart.com/settings/me)

3. **Add our metafields to the checkout object.**

    Open `store/checkout.js` and find the `this.$nacelle.checkout.process` method call. In a fresh Nacelle install, it looks like this:

    ```js
    let checkout = await this.$nacelle.checkout.process({ cartItems, checkoutId })
    ```

    To help Recart identify checkouts and orders, extend this line with `metafields`, like this:

    ```js
    let checkout = await this.$nacelle.checkout.process({
      cartItems,
      checkoutId,
      metafields: this.$recart.getMetafieldsForCheckout() // <-- add this line
    })
    ```

## Support

If you have any questions, feel free to contact Recart support at [support@recart.com](mailto:support@recart.com).

# Contributing

We really appreciate contributions.

If you have identified a bug, please open an Issue and provide as with as many details as possible.

If you have a suggestion to make the code better, feel free to submit a Pull Request. We only ask a few things from you:

- Write a short PR description, explaining the purpose of your solution.
- Write descriptive commit messages.
- Format the code according to the [Standard JS](https://standardjs.com/) guidelines and make sure the `npm run lint` command runs without errors.
- If possible, cover your changes with tests and make sure the `npm test` command runs without errors.
npm package: @recast-navigation/core
Description: Recast Navigation for JavaScript!
Author: Isaac Mason
Latest version: 0.43.1

# @recast-navigation/core

This package contains the the core functionality for `recast-navigation`. Please refer to the [main package's README](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation/README.md) for usage information.
npm package: @recast-navigation/generators
Description: NavMesh generator implementations for @recast-navigation/core
Author: Isaac Mason
Latest version: 0.43.1

# @recast-navigation/generators

This package contains "Preset" NavMesh generators for @recast-navigation/core that make getting started easy.

These can also be used as a basis for your own generator.

Please refer to the [main package's README](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation/README.md) for usage information.
npm package: @recast-navigation/playcanvas
Description: Utilities for using recast-navigation with PlayCanvas
Latest version: 0.43.1

# @recast-navigation/playcanvas

PlayCanvas nav mesh generation and visualisation helpers for [`recast-navigation`](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation).

## Installation

```bash
> npm install @recast-navigation/playcanvas recast-navigation
```

## Usage

### Importing

To import the PlayCanvas glue, you can either use the `playcanvas` entrypoint in `recast-navigation`:

```ts
import { init } from 'recast-navigation'
import { ... } from 'recast-navigation/playcanvas';
```

Or you can use the packages directly:

```ts
import { init } from '@recast-navigation/core'
import { ... } from '@recast-navigation/playcanvas';
```

### Initialization

Before you can use the library, you must initialize it. This is an asynchronous operation.

Calling `init()` after the library has already been initialized will return a promise that resolves immediately.

```ts
import { init } from 'recast-navigation';

await init();
```

### Generating a NavMesh

This package provides convenience functions for generating nav meshes from PlayCanvas MeshInstance objects.

```ts
import { init } from 'recast-navigation';
import { pcToSoloNavMesh, pcToTiledNavMesh, pcToTileCache } from 'recast-navigation/playcanvas';

/* initialize the library */
await init();

/* generate a solo navmesh */
const { success, navMesh } = pcToSoloNavMesh(meshInstances, {
  // ... nav mesh generation config ...
}});

/* generate a tiled navmesh */
const { success, navMesh } = pcToTiledNavMesh(meshInstances, {
  tileSize: 16,
  // ... nav mesh generation config ...
}});

/* generate a tile cache with support for temporary obstacles */
const { success, navMesh, tileCache } = pcToTileCache(meshInstances, {
  tileSize: 16,
  // ... nav mesh generation config ...
}});
```

### Interacting with a NavMesh

You can documentation for interacting with the generated navmesh in the core library README:

https://github.com/isaac-mason/recast-navigation-js

This library provides helpers that are used in conjunction with the core library.

### Helpers

This package provides helpers for visualizing various recast-navigation objects in PlayCanvas.

#### `NavMeshHelper`

```ts
import { NavMeshHelper } from '@recast-navigation/playcanvas';

const navMeshHelper = new NavMeshHelper(navMesh, graphicsDevice);

this.entity.addChild(navMeshHelper);

// update the helper when the navmesh changes
navMeshHelper.update();
```

#### `TileCacheHelper`

Visualises obstacles in a `TileCache`.

```ts
import { TileCacheHelper } from '@recast-navigation/playcanvas';

const tileCacheHelper = new TileCacheHelper(tileCache);

this.entity.addChild(tileCacheHelper);

// update the helper after adding or removing obstacles
tileCacheHelper.update();
```

#### `CrowdHelper`

Visualises agents in a `Crowd`.

```ts
import { CrowdHelper } from '@recast-navigation/playcanvas';

const crowdHelper = new CrowdHelper(crowd, graphicsDevice);

this.entity.addChild(crowdHelper);

// update the helper after updating the crowd
crowdHelper.update();
```
npm package: @recast-navigation/wasm
Description: A webassembly port of Recast Navigation
Author: Isaac Mason
Latest version: 0.43.1

# @recast-navigation/wasm

WASM build of Recast Navigation.

This library isn't intended for direct use - [`recast-navigation`](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation) is probably what you're looking for. It uses `@recast-navigation/wasm` internally, and provides a more friendly API.

This WASM build is based on the [Babylon.js Recast Navigation Extension](https://github.com/BabylonJS/Extensions/tree/master/recastjs).
npm package: @recats/eslint-config
Description: ESLint preset extending Airbnb, Flow and Jest
Author: Strelkov Dmitry
Latest version: 1.0.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# eslint-config-recats

[![npm](https://img.shields.io/npm/v/@recats/eslint-config.svg)](https://www.npmjs.com/package/@recats/eslint-config)
[![Greenkeeper badge](https://badges.greenkeeper.io/recats/eslint-config-recats.svg)](https://greenkeeper.io/)
![Recats Digital](https://img.shields.io/badge/recats-digital-1abc9c.svg?style=flat)

Plugins and configs used:
* [eslint-config-airbnb](https://yarnpkg.com/en/package/eslint-config-airbnb)
* [eslint-plugin-flowtype](https://yarnpkg.com/en/package/eslint-plugin-flowtype)
* [eslint-plugin-jest](https://yarnpkg.com/en/package/eslint-plugin-jest)

Additionally, it sets these environments:
```json
{
  "env": {
    "browser": true,
    "es6": true,
    "node": true
  }
}
```

## Installation
```
yarn add eslint @recats/eslint-config eslint --dev
```

## Usage
Add to your eslint config `.eslintrc`:

```json
{
  "extends": "@recats/eslint-config"
}
```

### Example of extending the configuration

```json
{
  "extends": "@recats/eslint-config",
  "rules": {
    ...
  }
}
```
npm package: @recc/api
Description: Frontend API for the recc core
Author: zer0
Latest version: 2.0.4

# @recc/api

Frontend API for the recc core

## Project setup
```.shell
yarn install
```

### Compiles and minifies for production
```.shell
yarn build
```

### Style check
```.shell
yarn style
```

### Lints and fixes files
```.shell
yarn lint
```

### Run your unit tests
```.shell
yarn test
```

## License

See the [LICENSE](./LICENSE) file for details. In summary,
**@recc/api** is licensed under the **MIT license**.
npm package: @receitasdoparaiso/eslint-config
Description: ESLint configuration used by receitasdoparaiso.
Latest version: 1.0.0

# Receitas do Paraiso ESLint config

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Prettier;

## Setup

### React (with Next.js)

Install dependencies:
```
npm i -D eslint @receitasdoparaiso/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": [
    "@receitasdoparaiso/eslint-config/next", 
    "next/core-web-vitals"
  ]
}
```

### React (without Next.js)

Install dependencies:
```
npm i -D eslint @receitasdoparaiso/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": "@receitasdoparaiso/eslint-config/react"
}
```

### Node.js

Install dependencies:
```
npm i -D eslint @receitasdoparaiso/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": "@receitasdoparaiso/eslint-config/node"
}
```
npm package: @recent-cli/expand-paths
Description: Quick way to resolve windows userdata and home paths
Author: Ash
Latest version: 0.0.3

# Expand-Paths



### Install

```bash
$ yarn add @recent-cli/expand-paths
```

```bash
$ npm -i @recent-cli/expand-paths
```



### Usage

```javascript
const {expandUserPath, expandAppData} = require('@recent-cli/expand-paths')

// To resolve a path in the user's home folder

console.log(
    expand.expandUserPath(".bash_profile") 
);

console.log(
    expand.expandUserPath(".bash_profile", true) //# ensures path exists
);

// To resolve the user's AppData folder (Windows only. Returns null otherwise)
console.log(
    expand.expandAppData(".bash_profile", true) //# ensures path exists
);

```



*Created for: @recent-cli tool*
npm package: @recent-cli/jumplist-parser-lite
Description: A safe & non-forensic, Windows Jumplist parser.
Latest version: 0.0.1

# Jumplist Parser Lite

A safe, tiny (3.2 Kib), pure JS, Jumplist parser.

JumpList Parser Lite has only one goal - **Find all unique paths inside jumplists.** 

![CI](https://github.com/ashbeats/jumplist-parser-lite/workflows/CI/badge.svg?branch=master&event=push)

## Installation

```bash
yarn add @recent-cli/jumplist-parser-lite
```


## Usage

For Automatic destination files

```javascript
const { automatic_destination_parser } = require("@recent-cli/jumplist-parser-lite");

// bytes should contain a Buffer containing the target file. 
const array_of_destinations = automatic_destination_parser(bytes);
console.log(array_of_destinations);
```

For Custom destination files

```javascript
const { custom_destination_parser } = require("@recent-cli/jumplist-parser-lite");

// bytes should contain a Buffer containing the target file. 
const array_of_destinations = custom_destination_parser(bytes);
console.log(array_of_destinations);
```

See `tests/` for more usage information. 


## So, What are Jumplists?

Jump Lists are a Windows feature that gives the user quick access to recently accessed application files and actions.

Jump Lists come in 2 main types:

- automatic (autodest, or *.automaticDestinations-ms) files
- custom (custdest, or *.customDestinations-ms) files


## Reason for this package

##### Pure NodeJS parser & non-forensic use case

I wanted something that could be included in packages that does not raise privacy concerns and auto flagging by vulnerability scanner bots, like my `@recent-cli` tool. Also, relying on compiled libraries was not ideal for my use case.

Unlike forensic Jumplist parsers which seek to identify and extract all meta-data that can be used to infer user's activity and patterns, *<u>No user identifiable information is returned</u>* from **JumpList Parser Lite**. Only destinations.

Don't get me wrong. 

Forensic tools have a place, just not in widely used *non-forensic* open-source packages. 

If you are looking for a forensic parser, I recommend [Eric Zimmerman's awesome JLECmd](https://github.com/EricZimmerman/JLECmd). It's a great tool for researchers and security consultants. (I can't thank Eric's code enough. It helped me to write this parser)



## References

- [Forensics Wiki On Jumplists](https://web.archive.org/web/20190829145904/http://forensicswiki.org/wiki/Jump_Lists)
- [Jump lists in depth (includes changes from Windows 10)](https://web.archive.org/web/20190829145904/http://binaryforay.blogspot.com/2016/02/jump-lists-in-depth-understand-format.html), by [Eric Zimmerman](https://github.com/EricZimmerman)
npm package: @recent-cli/resolve-lnk
Description: Resolves basic information from windows lnk files using pure js
Author: Ash
Latest version: 0.0.2

# Resolve Lnk

Easily extract destinations from Windows shortcut files (*.lnk)



**Benefits**

- Fast. Written in pure JS. 
- Tiny library! ( 3.85 KiB )
- Does not depend on external tools, Wscript or COM calls. 



## What are Lnk files?

Shell Link (.LNK) Binary File Format, which contains information that can be used to access another data object. The Shell Link Binary File Format is the format of Windows files with the extension "LNK".

Shortcuts on Windows, are lnk files. 



## Install ![All Tests](https://github.com/ashbeats/resolve-lnk/workflows/All%20Tests/badge.svg)

```bash
$ yarn add @recent-cli/resolve-lnk
```



## Usage

```javascript
const Lnk = require("@recent-cli/resolve-lnk")

// # Supports Buffer | Uint8Array input
let output = Lnk.resolveBuffer(
    fs.readFileSync()
); 

// # Supports path names. Returns a Promise
(async () => await Lnk.resolve("example.lnk"))();

```





#### Todo

- Add support for the browser
npm package: @recepbayraktar/openapi-agent-tools
Description: Hey API plugin that generates framework-agnostic tool descriptors from OpenAPI specs
Author: Recep Bayraktar
Latest version: 0.1.2

# @recepbayraktar/openapi-agent-tools

[![CI](https://github.com/recepbayraktar/openapi-chat-tools/actions/workflows/ci.yml/badge.svg)](https://github.com/recepbayraktar/openapi-chat-tools/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Generate framework-agnostic tool descriptors from OpenAPI specs with a Hey API plugin.

## Install

```bash
pnpm add -D @recepbayraktar/openapi-agent-tools @hey-api/openapi-ts
```

## Quick Start

```ts
// openapi-ts.config.ts
import { defineConfig } from "@hey-api/openapi-ts";

export default defineConfig({
  input: "./openapi.json",
  output: "./src/generated",
  plugins: [
    "@hey-api/client-fetch",
    {
      name: "@recepbayraktar/openapi-agent-tools",
    },
  ],
});
```

```bash
npx openapi-ts
```

Default output file:

```text
src/generated/tool-descriptors.gen.ts
```

## Generated Exports

- `toolDescriptors: ToolDescriptor[]`
- `toolDescriptorMap: Record<string, ToolDescriptor>`

## Provider Integrations

Descriptor output stays provider-agnostic by default.

If you enable a provider integration, the generated file also includes provider-specific exports.

### Vercel AI SDK

```ts
{
  name: "@recepbayraktar/openapi-agent-tools",
  providers: {
    vercelAiSdk: {
      enabled: true,
    },
  },
}
```

When enabled, generated output adds a direct `tools` export compatible with AI SDK tool maps.

```ts
import { tools as generatedTools } from "./generated/tool-descriptors.gen";

export const tools = {
  ...generatedTools,
  get_user_by_id: {
    ...generatedTools.get_user_by_id,
    execute: async (input) => api.getUserById(input),
  },
};
```

Generated tools expose both `inputSchema` and `parameters` for AI SDK version compatibility.

## Notes

- Every operation should define `operationId`.
- If filters remove all operations, generation fails with `E_SPEC_NO_OPERATIONS_MATCHED`.
- `toolName` collisions fail generation.

## Docs

- [Getting Started](./docs/getting-started.md)
- [Configuration](./docs/configuration.md)
- [Generated Output](./docs/generated-output.md)
- [Examples](./docs/examples.md)
- [Troubleshooting](./docs/troubleshooting.md)

## Development

```bash
pnpm install
pnpm lint
pnpm test
pnpm build
```
npm package: @receptron/agentdoc
Description: GraphAI agent document generator.
Author: Receptron team
Latest version: 1.0.3

# GraphAI agentdoc🤖

GraphAI agent document generator

## Install 🚀

```sh
npm i -g  @receptron/agentdoc
```

## Usage 📖 

In agent root directory,

```
npx agentdoc
```
npm package: @receptron/event_agent_generator
Description: Demo
Author: Receptron team
Latest version: 0.0.6


## Event Agent generator

Demo

https://github.com/user-attachments/assets/721d4dc8-7cd3-4cef-9135-8e85b1287d31


### install

```sh
yarn add @receptron/event_agent_generator
```

### Usage

```html
<div class="w-10/12 bg-white">
  <div v-if="Object.values(events).length > 0">
    <div v-for="(event, k) in Object.values(events)" class="flex" :key="k">
      <div v-if="event.type === 'button'">
        <button class="text-white font-bold items-center rounded-md px-4 py-2 ml-1 hover:bg-sky-700 flex-none m-4 bg-sky-500" @click="buttonClick(event)">
          event
        </button>
      </div>
      <div v-if="event.type === 'text'">
        <input v-model="userInputs[event.id]" class="border-2 p-2 rounded-md flex-1 m-4" :placeholder="event.nodeId" />
        <button class="text-white font-bold items-center rounded-md px-4 py-2 ml-1 hover:bg-sky-700 flex-none m-4 bg-sky-500" @click="textClick(event)">
          Submit
        </button>
      </div>
    </div>
  </div>
</div>
```

```typescript
import { defineComponent, ref } from "vue";

import { GraphAI } from "graphai";
import { eventAgentGenerator } from "@receptron/event_agent_generator";

export default defineComponent({
  setup() {
    const userInputs = ref({});
    
    const events = ref({});
    const { eventAgent } = eventAgentGenerator((id, data) => {
      events.value[id] = data;
    });
    const buttonClick = (event) => {
      event.onEnd({ data: 123 });
      delete events.value[event.id];
    };

    const textClick = (event) => {
      const text = userInputs.value[event.id];
      const data = {
        text,
        message: { role: "user", content: text },
      };
      event.onEnd(data);
      delete events.value[event.id];
    };

    const run = async () => {
      const graphai = new GraphAI(graphData, { ...vanilla, eventAgent });
      const result = await graphai.run(true);
      console.log(result);
    };
    run();

    return {
      userInputs,

      events,
      buttonClick,
      textClick,
    };
  }
});
```
npm package: @receptron/firebase-tools
Description: GraphAI firebase web tools.
Author: Receptron team
Latest version: 1.0.0

# GraphAI Firebase web tools


Call agents with streaming support by combining Firebase Functions with @receptron/graphai_firebase_functions.

```
  import { buildFirebaseStreamFilter } from "@receptron/firebase-tools";
  
  const { firebaseStreamFilter } = buildFirebaseStreamFilter(firebaseApp, "asia-northeast1", "agent");

  const agentFilters: AgentFilterInfo[] = [
    {
      name: "streamAgentFilter",
      agent: streamAgentFilter,
    },
    {
      name: "firebaseStreamFilter",
      agent: firebaseStreamFilter,
      agentIds: ["openAIAgent"],
    }
  ];
  const graphai = new GraphAI(
    graphData,
    agents,
    {
      agentFilters,
    }
  );
```
npm package: @receptron/graphai_express
Description: GraphAI express web server middleware.
Author: Receptron team
Latest version: 3.0.2


## GraphAI express middleware.

## Install

```
yarn add @receptron/graphai_express
```

## Usage

```TypeScript

import express from "express";
import * as agents from "@graphai/agents";
import { agentDispatcher, nonStreamAgentDispatcher, streamAgentDispatcher, agentsList, agentDoc, graphRunner} from "@receptron/graphai_express";
import { AgentFunctionInfoDictionary } from "graphai";

const agentDictionary: AgentFunctionInfoDictionary = agents;
const hostName = "https://example.net";
const apiAgentPrefix = "/api/agents";
const apiGraphPrefix = "/api/graph";

app.get(apiAgentPrefix + "/:agentId", agentDoc(agentDictionary, hostName, apiAgentPrefix)); // each API(agent) document
app.get(apiAgentPrefix + "/", agentsList(agentDictionary, hostName, apiAgentPrefix));  // API(agent) list

// non stream and stream agent server
app.post(apiAgentPrefix + "/:agentId", agentDispatcher(agentDictionary));

// non stream agent server
app.post(apiAgentPrefix + "/nonstream/:agentId", nonStreamAgentDispatcher(agentDictionary));

// stream agent server
app.post(apiAgentPrefix + "/stream/:agentId", streamAgentDispatcher(agentDictionary));

// non stream and stream agent server
app.post(apiGraphPrefix + "/", graphRunner(agentDictionary));

// OpenAI completions Compatible API
app.post("/api/chat/completions", completionRunner(agentDictionary, model2graphData, [], onLogCallback));

```

### Run Test server

```
yarn run server
```


### Test from curl

```
curl -X POST -H "Content-Type: application/json" -d '{"params": {"message" : "hello"}}' http://localhost:8085/api/agents/echoAgent
```

### from GraphAI Client

```
npx ts-node  test/stream_graph.ts
```

### for this middleware development

```
git clone https://github.com/receptron/graphai_utils
cd packages/express
yarn install
yarn run server # then run test express server
yarn run test_stream
```
npm package: @receptron/graphai_firebase_functions
Description: GraphAI firebase functions tools.
Author: Receptron team
Latest version: 1.0.1


## GraphAI firebase function stream runner

## Install

```
yarn add @receptron/graphai_firebase_functions
```

## Usage

```TypeScript
import { openAIAgent } from "@graphai/openai_agent";
import { CallableRequest, CallableResponse, HttpsError } from "firebase-functions/v2/https";
import type { AgentFunctionContext, AgentFunctionInfoDictionary } from "graphai";

import { StreamChunkCallback, runAgentOnCall } from "@receptron/graphai_firebase_functions";

const agentDictionary: AgentFunctionInfoDictionary = {
  openAIAgent,
};

export const agentRunner = async (request: CallableRequest, response?: CallableResponse) => {
  const uid = request.auth?.uid;

  if (!uid) {
    throw new HttpsError("unauthenticated", "Authentication required");
  }

  const streamCallback: StreamChunkCallback = (context: AgentFunctionContext, token: string) => {
    response?.sendChunk({
      delta: token,
      type: "agent",
      nodeId: context.debugInfo.nodeId,
      agentId: context.debugInfo.agentId,
    });
  };

  return await runAgentOnCall(request, agentDictionary, { streamCallback });
};
```
npm package: @receptron/graphai_vue_cytoscape
Description: ### install
Author: Receptron team
Latest version: 0.2.0


## Composable to show GraphAI state to Vue using cytoscape

### install

```sh
yarn add @receptron/graphai_vue_cytoscape
```

### Usage


```typescript
import { defineComponent, ref } from "vue";

import { GraphAI } from "graphai";
import { useCytoscape } from "@receptron/graphai_vue_cytoscape";

export default defineComponent({
  setup() {
    const selectdGraph = ref(graphData)
    const { updateCytoscape, cytoscapeRef, resetCytoscape } = useCytoscape(selectdGraph);
    
    const run = async () => {
      const graphai = new GraphAI(selectdGraph.value, agents);
      graphai.registerCallback(updateCytoscape);
      await graphai.run();
    }
    run();

    return {
      cytoscapeRef
    };
  }
});
```

### requirement

GraphAI 0.6.23 or above