open-index/open-npm huggingface dataset:
npm package: @flyweel/skill
Description: Install Flyweel ad analysis skills for any AI coding agent
Author: Flyweel
Latest version: 1.0.6

# @flyweel/skill

Install [Flyweel](https://flyweel.co) ad analysis skills for any AI coding agent — Claude Code, Cursor, Windsurf, Gemini CLI, Codex, OpenCode, and more. One command to install, update, or remove. Auto-detects your agents.

## Quick Start

```bash
npx @flyweel/skill install flyweel-mcp-deep-ad-analysis
```

Auto-detects which agents you have installed and configures each one.

## Commands

```bash
# List available skills and supported agents
npx @flyweel/skill

# Install a skill (auto-detects your agents)
npx @flyweel/skill install <skill-name>

# Install for a specific agent
npx @flyweel/skill install <skill-name> --agent=cursor
npx @flyweel/skill install <skill-name> --agent=claude-code,gemini

# Install for all supported agents
npx @flyweel/skill install <skill-name> --agent=all

# Install all Flyweel skills
npx @flyweel/skill install --all

# Update (re-run install)
npx @flyweel/skill install <skill-name>

# Remove a skill from all agents
npx @flyweel/skill remove <skill-name>
```

## Available Skills

| Skill | Description |
|---|---|
| `flyweel-mcp-deep-ad-analysis` | Analyse Google Ads and Meta Ads with the Flyweel MCP server |
| `ad-performance-analyser-flyweel` | Analyse ad spend across Google, Meta, LinkedIn, and TikTok from any data source |

## Supported Agents

| Agent | How it installs |
|---|---|
| **Claude Code** | Clones to `~/.claude/skills/` |
| **Cursor** | Copies as `.mdc` rule to `~/.cursor/rules/` |
| **Windsurf** | Copies as `.md` rule to `~/.windsurf/rules/` |
| **Codex CLI** | Appends to `~/.codex/instructions.md` |
| **Gemini CLI** | Appends to `~/.gemini/GEMINI.md` |
| **OpenCode** | Appends to `~/.opencode/instructions.md` |

## Built by Flyweel

Originally built by [Flyweel](https://flyweel.co) — we're building the layer connecting spend, revenue, and capital with agentic finance.

## License

MIT
npm package: @flyweight.cloud/airtable2swagger
Description: Quickly build airtable swagger definitions from just the API data
Author: Mark Percival
Latest version: 0.0.5

![Flyweight Cloud_2_cropped_400](https://user-images.githubusercontent.com/2868/138356735-fff5eb7e-2212-4380-a91b-5c715fe16be6.png)


# Flyweight Airtable2Swagger
[![Tests](https://github.com/flyweightcloud/airtable2swagger/actions/workflows/test.yml/badge.svg)](https://github.com/flyweightcloud/airtable2swagger/actions/workflows/test.yml)

A tool for building Swagger 2.0 definitions from a single Airtable API query.

**2021.10.21 - Warning, this is in beta and subject to change**

## Why

There's no easy way to start using Airtable from Microsofts ecosystem (PowerApps / Flow).

This seeks to resolve that issue.

## CLI Usage

- Simply visit [https://airtable.com/api](https://airtable.com/api) and select your workspace.
- Find the URL for the table you want to access (e.g. https://api.airtable.com/v0/app7Ns7bmcPNrCI3a/MyTable
- Get you API key from [https://airtable.com/account](https://airtable.com/account)
- Run the command below, but with the details from above inserted

`npx @flyweight.cloud/airtable2swagger https://api.airtable.com/v0/WorkSpaceID/MyTable?api_key=API_KEY  > swagger.json`

## Self-serve

Coming soon, a self-serve way to do this without and command line or code required.

## Testing

```
npm ci
npm test
```
npm package: @flyweight.cloud/az-fn-mocks
Description: A simple and lightweight library to quickly build mocks and unit test Azure Functions
Author: Mark Percival
Latest version: 0.1.2

# A lightweight and opinionated tool for mocking Azure Function Contexts

The goal of this library is to provide a very simple way to unit test Azure Functions.

Unit testing of Azure Functions should simply exercise the functions use of the context object,
but not involve the bindings or function.json. This is better handled at the intergration testing
level, which will likely involve the use of the Azure Function CLI.

## Gettings started

`npm install --dev @flyweightcloud/azure-fn-context-mocks`

With Yarn

`yarn add --dev @flyweightcloud/azure-fn-context-mocks`

## A simple mocking example

```javascript
import { AzureFunction, Context } from "@azure/functions"
import { AzureContextMock, MockForm, TestHttpRequest } from "..";

const testFn: AzureFunction = (context: Context) => {
    context.log.info("test function")
    const form = context.req?.parseFormBody()
    context.res = {
        status: 200,
        body: {
            name: form?.get("name")?.value.toString(),
            city: context.req?.query.city
        }
    };
}

describe("Basic HTTP Context Test object", () => {
    it("Should work with just the simple Context object passed in", async () => {
        const req = new TestHttpRequest({method: "POST", query: {"city": "Atlanta"}})
        req.parseFormBody = jest.fn().mockReturnValue(new MockForm([["name", "Mark"]]))
        const context = new AzureContextMock({ req, log: "suppressed"})
        await testFn(context, req)
        const res = context.res
        if (!res) throw fail("Context did not have a response object")
        expect(res.body.name).toEqual("Mark")
        expect(res.body.city).toEqual("Atlanta")
        expect(res.status).toEqual(200)
    })
})
```
npm package: @flyweight.cloud/openroute
Description: A lightweight router for Azure Functions with Swagger integration
Author: Mark Percival
Latest version: 0.6.3

# Flyweight OpenRoute

A lightweight framework for building Swagger/OpenAPI serverless functions for consumption
by Microsoft Power Platform and beyond.

## Installation

`npm i --save @flyweight.cloud/openroute`

## Usage

The goal is for OpenRoute to require little to no modification of your Azure handlers


```typescript
import { Context, HttpRequest } from "@azure/functions"
import { get } from "@flyweight.cloud/request";
import Swaggerist, { schemaBuilder, Responses, queryParamBuilder, pathParamBuilder } from "@flyweight.cloud/swaggerist";
import { OpenRoute } from "@flyweight.cloud/openroute"
import { HttpError } from "@flyweight.cloud/openroute/lib/errors";

const API_KEY = process.env.OPENWEATHER_API_KEY;

const exampleWeatherApiResponse = {
  "coord": {
    "lon": -122.08,
    "lat": 37.39
  },
  "weather": [
    {
      "id": 800,
      "main": "Clear",
      "description": "clear sky",
      "icon": "01d"
    }
  ],
  "base": "stations"
};

const swaggerBuilder = Swaggerist.create({
  info: {
    title: "Weather API",
    description: "Flyweights demo weather API",
    version: "1.0.0",
  }
})

const app = new OpenRoute({
  swaggerBuilder,
  cors: {
    allowOrigin: "*",
    allowHeaders: ["*"],
    allowMethods: ["*"],
  }
});

const getCurrentWeatherPathRoute = swaggerBuilder.get("/current/{zipCode}", {
  operationId: "getCurrentWeatherByZip",
  parameters: [...pathParamBuilder({zipCode: "12345"})],
  responses: {
    200: Responses.Success(schemaBuilder(exampleWeatherApiResponse)),
  }
})

app.route(getCurrentWeatherPathRoute, async (context: Context, req: HttpRequest, openRoute: OpenRoute): Promise<void> => {
    context.log("HTTP trigger function processed a request.");

    const zipCode = context.bindingData.zipCode
    let url = `https://api.openweathermap.org/data/2.5/weather?zip=${zipCode}&appid=${API_KEY}`
    const weather = await get(url)

    context.res = {
        body: weather.body,
        headers: openRoute.defaultHeaders(),
    };

});

export default app.getHttpTrigger();
```

You will also need to modify function.json to add a 'catch-all' route
`"route": "weather/{*route}"`

Check out [DemoFunc](https://github.com/flyweightcloud/openroute-azure-demo) to see the full featured function and it's settings.
npm package: @flyweight.cloud/yaml2jsish
Description: Basic conversion of YAML to JSON/TS/JS with glob support
Latest version: 0.2.0

# yaml2jsish

A CLI driven converter for taking YAML files and converting them to JS/JSON/Typescript.

This is mostly a utility script for convering Swagger definitions written in YAML into a format
that is compilable and consumable by a Javascript application.

## Install

Should be a development dependency so that it can be pruned before a deploy to production

`npm install @flyweight.cloud/yaml2jsish --save-dev`

## Usage

`yaml2jsish "**/*.yaml" --type ts`
npm package: @flywen/global-mouse-events
Description: Global mouse events listener for Node.js (Windows only)
Author: xanderfrangos
Latest version: 1.1.0

# global-mouse-events

Global mouse events listener for Node.js (Windows only). Based off of [sentialx/mouse-hooks](https://github.com/sentialx/mouse-hooks) and [coldKey1/mouse-hooks](https://github.com/coldKey1/mouse-hooks).

## Installation

```cmd
npm i global-mouse-events
```

## Usage
Import the module and register for the mouse events you'd like to listen to.

### Available event listeners

**`mouseup`** / **`mousedown`** — *Fires when a mouse button is pressed / released.*\
Returns:
- **x:** The X position of the mouse, relative to the top left of the primary display.
- **y:** The Y position of the mouse, relative to the top left of the primary display.
- **button:** Which button was pressed. 1 is left-click. 2 is right-click. 3 is middle-click.

**`mousemove`** — *Fires when the mouse cursor is moved.*\
Returns:
- **x:** The X position of the mouse, relative to the top left of the primary display.
- **y:** The Y position of the mouse, relative to the top left of the primary display.

**`mousewheel`** — *Fires when the mouse wheel is scrolled. Some trackpads may not fire this event unless "Scroll inactive windows when I hover over them" is disabled in the Windows settings.*\
Returns:
- **x:** The X position of the mouse, relative to the top left of the primary display.
- **y:** The Y position of the mouse, relative to the top left of the primary display.
- **delta:** How much the mouse wheel was scrolled. Positive numbers are considered "up" and negative numbers are "down".
- **axis:** Whether the scroll was vertical or horizontal. 0 is vertical. 1 is horizontal.

### Example

```js
const mouseEvents = require("global-mouse-events");

mouseEvents.on("mouseup", event => {
  console.log(event); // { x: 2962, y: 483, button: 1 }
});

mouseEvents.on("mousedown", event => {
  console.log(event); // { x: 2962, y: 483, button: 1 }
});

mouseEvents.on("mousemove", event => {
  console.log(event); // { x: 2962, y: 482 }
});

mouseEvents.on("mousewheel", event => {
  console.log(event); // { x: 2962, y: 483, delta: -1, axis: 0 }
});
```

### Available functions

- **`pauseMouseEvents`** — *Pauses all mouse events.*
- **`resumeMouseEvents`** — *Resumes all mouse events.*
- **`getPaused`** — *Returns the paused state as a boolean.*
npm package: @flywheel-io/fw-file-rs
Description: JavaScript/WebAssembly bindings for fw-file rust crate
Latest version: 0.6.2

# fw-file-rs

JavaScript/WebAssembly bindings for the [fw-file-rs][fw-file-rs-repo] Rust library.
This package lets you work with DICOM files directly in the browser.

## Usage

```js
import init, { Context, read_until_pixels } from "fw-file-rs/dcm";

// initialize the WASM module (required before use)
await init();
// Create a configured context using the builder pattern
const ctx = new Context()
    .parse_include([
        "InstitutionAddress",
        "InstitutionName",
    ])
    .group_by(["StudyInstanceUID", "SeriesInstanceUID"])
    .split_localizer(true)
    .deid_profile(`
        version: 1
        name: profile
        dicom:
          fields:
            - name: PatientName
              replace-with: REDACTED
    `);
// Read DICOM header bytes from file
const headerBytes = await ctx.read_until_pixels(file);
// Extract metadata using the configured context
const meta = ctx.parse_header(headerBytes);
// Get Flywheel-specific metadata
const fwMeta = ctx.get_fw_meta(meta);
// Group DICOM files by configured tags with localizer splitting
const path_meta_pairs = [["1.dcm", meta]];
const groups = ctx.group_series(path_meta_pairs);
// De-identify the DICOM header using the configured profile
const deidHeaderBytes = ctx.deid_header(headerBytes);
// Prepare chunks for upload
const chunks = [];
chunks.push(new Blob([deidHeaderBytes]));
let start = headerBytes.length;
while (start < file.size) {
    const chunkSize = Math.min(file.size - start, CHUNK_SIZE);
    chunks.push(file.slice(start, start + chunkSize));
    start += chunkSize;
}
// chunks are ready to be uploaded
```

[fw-file-rs-repo]: https://gitlab.com/flywheel-io/tools/lib/fw-file-rs
npm package: @flywheel-io/ohif-remote
Description: Library for host applications to control the OHIF viewer using iframe postMessage RPC
Author: Jody Zeitler
Latest version: 0.1.2

OHIF Remote
===========

Library for host applications to control the OHIF viewer using iframe postMessage RPC

Getting Started
---------------

Install this package with NPM.

```shell
npm install @flywheel-io/ohif-remote
```

Import [OHIFRemote](https://cdn.flywheel.io/docs/ohif-remote/0.1.2/classes/OHIFRemote.html) and attach it to a new or existing OHIF viewer iframe. This example creates a new iframe pointing to `https://dev.flywheel.io/ohif-viewer?remote`. The `?remote` query parameter is important, and tells the OHIF viewer to wait for a connection before initializing.

Register event callbacks and connect to the OHIF viewer. Invoke methods (set project and open task) within the [Init](https://cdn.flywheel.io/docs/ohif-remote/0.1.2/enums/RemoteEvent.html#Init) event callback.

```js
import { OHIFRemote, RemoteEvent } from '@flywheel-io/ohif-remote';

(function init() {
  const $iframe = document.createElement('iframe');
  $iframe.src = 'https://dev.flywheel.io/ohif-viewer?remote';
  $iframe.style.width = 'calc(100vw - 24px)';
  $iframe.style.height = 'calc(100vh - 24px)';
  document.body.appendChild($iframe);

  $iframe.addEventListener('load', () => {
    const ohif = new OHIFRemote({
      receiveWindow: window,
      sendWindow: $iframe.contentWindow,
      targetUrl: $iframe.src,
    });
    ohif.on(RemoteEvent.Init, () => {
      console.log('OHIFRemote initialized');
      ohif
        .setProject('61095a04703bfa1fdbcf6613')
        .openTask('61655e0434090f77efe5ec0e');
    });
    ohif.on(RemoteEvent.TaskOpened, ({ task }) => {
      console.log(`Task ${task._id} opened`);
    });
    ohif.connect();
  });
}());
```

Events and Methods
------------------

A connected [OHIFRemote](https://cdn.flywheel.io/docs/ohif-remote/0.1.2/classes/OHIFRemote.html) instance can listen to [events](https://cdn.flywheel.io/docs/ohif-remote/0.1.2/enums/RemoteEvent.html) from and issue [methods](https://cdn.flywheel.io/docs/ohif-remote/0.1.2/classes/OHIFRemote.html#setProject) to the OHIF viewer.

Listening to an event example:
```js
ohif.on(RemoteEvent.TaskOpened, ({ task }) => {
  console.log(`Task ${task._id} opened`);
});
```

Calling methods example:
```js
ohif
  .setProject('61095a04703bfa1fdbcf6613')
  .openTask('61655e0434090f77efe5ec0e');
```