open-index/open-npm huggingface dataset:
npm package: @operarius/vue-cli-generator
Description: Vue CLI preset for project generation
Author: Alex Tkachenko
Latest version: 0.3.5

# Vue project generator

This is generator library based on `@vue/cli` v3 with predefined presets.

Presets available:
- `project` - Preset for vue project.
- `plugin` - Preset for vue plugin development(might be used for any javascript library development). With hot reloading example playground.

## Installation

Plugins are developed to use `yarn` as a default package manager. If you are using `npm` - you would need to change scripts call in your newly generated `package.json`.

```bash
yarn global add @operarius/vue-cli-generator
```

## Usage

You may use a long command name(`operarius-vue-create`), or a shortcut(`ovc`) for a new project generation.

```bash
ovc [project-name] [preset]
```

Where `project-name` is your project name, and `preset` is the name of the preset(all available are listed above).
npm package: @operate-first/probot-metrics
Description: Probot extension to expose Prometheus metrics
Author: Tom Coufal
Latest version: 1.0.0

# Probot metrics endpoint

This extension enables you to expose Prometheus metrics from Probot with ease. It's a simple wrapper on top of `prom-client`.

## Installation

```bash
npm install --save @operate-first/probot-metrics
```

## Overview

- `useCounter(options)`: registers a Counter metric, consumes options for [Counter](https://github.com/siimon/prom-client#counter).
- `useGauge(options)`: registers a Gauge metric, consumes options for [Gauge](https://github.com/siimon/prom-client#gauge).
- `useHistogram(options)`: registers a Histogram metric, consumes options for [Histogram](https://github.com/siimon/prom-client#histogram).
- `useSummary(options)`: registers a Summary metric, consumes options for [Summary](https://github.com/siimon/prom-client#summary).
- `exposeMetrics(route)` to expose HTTP route from Probot on `<route>` (defaults to `/metrics`). Use as a [Probot HTTP route](https://probot.github.io/docs/http/):

## Usage

If you want to leverage this extension, it is required that your Probot instance has [a server exposed](https://probot.github.io/docs/http/) (This extension currently supports Prometheus PULL mode only, serverless deployments don't work like that.)

```js
const metrics = require('@operate-first/probot-metrics');

module.exports = (app, { getRouter }) => {
    const router = getRouter();
    metrics.exposeMetrics(router, '/metrics');
}
```

By default this extension tracks default Node.js metrics and exposes them (with `probot_` prefix). In addition to that you can define your own custom metrics.

### Define custom metrics

You can use `useCounter`, `useGauge`, `useHistogram` and `useSummary` to define custom metrics.

```js
const metrics = require('@operate-first/probot-metrics');

module.exports = app => {
    // Exposing the route is required in all cases
    //...

    const numberOfActionsTotal = metrics.useCounter({
        name: 'num_of_actions_total',
        help: 'Total number of actions received',
        labelNames: ['install', 'action'],
    });

    app.onAny((context) => {
        numberOfActionsTotal
        .labels({
            install: context.payload.installation.id,
            action: context.payload.action,
        })
        .inc();
    });
}
```
npm package: @operate/agent
Description: Operate JavaScript agent used to load and run Bitcoin programs.
Author: Chronos Labs Ltd
Latest version: 0.1.0-beta.1

# Operate | Agent (js)

**Operate | Agent (js)** is a JavaScript agent used to load and run programs (known as "tapes") encoded in Bitcoin SV transactions.

## About Operate

Operate is a toolset to help developers build applications, games and services on top of Bitcoin (SV). It lets you write functions, called "Ops", and enables transactions to become small but powerful programs, capable of delivering new classes of services layered over Bitcoin.

More infomation:

* [Project website](https://www.operatebsv.org)
* [API documentation](https://operate-bsv.github.io/op_agent-js)

## Installation

Install using NPM:

```console
npm install @operate/agent
```

```javascript
const Operate = require('@operate/agent')
```

Or use in the browser via CDN (adds `Operate` to the global namespace):

```html
<script src="//unpkg.com/@operate/agent@latest/dist/operate.min.js"></script>
```

## Quick start

### Aliases

To kick the styles, set up some aliases for common Bitcom protocol prefixes. This will allow you to load and run tapes from common services such as Bitpaste, Twetch, WeatherSV, Bit.sv and more.

```javascript
Operate.config.quickStartAliases()
```

### Load and run a tape

Operate can be used straight away to load and run tapes from transactions.

```javascript
const tape = await Operate.loadTape(txid)
const result = await Operate.runTape(tape)
```

Operate always returns table structures from the Lua environment as a JavaScript `Map`. If preferred, these can be converted to an `Object` for easier data traversal and access.

```javascript
Operate.util.mapToObject(result)
```

## Beta software

This software should be considered beta. There are a few known issues and things that may change over time:

* API changes. The current implmentation closely mirrors the design of the [Elixir agent](https://github.com/operate-bsv/op_agent). Elixir and JavaScript semantics are quite different so over time the API design may change to reflect more idiomatic JavaScript styles.
* Error handling sucks. If something goes wrong, especially in the Lua VM, the error you get back will almost certainly not be very useful. This will be improved over time.
* Bundle size. The minimised bundle currently weighs in at over 700kb! I think it will be possible to get this under 300kb, but this will take work and time.


## License

[MIT License](https://github.com/operate-bsv/op_agent-js/blob/master/LICENSE.md).

© Copyright 2020 Chronos Labs Ltd.
npm package: @operate/cli
Description: Operate command line utility to help developers author and publish Ops (functions) on the BSV blockchain.
Author: libitx
Latest version: 0.0.2

# Operate | CLI

Operate command line utility to help developers author and publish Ops (functions) on the BSV blockchain.

## About Operate

Operate is a toolset to help developers build applications, games and services on top of Bitcoin (SV). It lets you write functions, called "Ops", and enables transactions to become small but powerful programs, capable of delivering new classes of services layered over Bitcoin.

More infomation:

* [Project website](https://www.operatebsv.org)

## Installation

The CLI is a `npm` package. It can be installed using `npm` or `yarn`.

```bash
# Install with npm
> npm install -g @operate/cli

# Install with yarn
> yarn global add @operate/cli
```

## Usage

### Getting started

Initialise your working directory. This will generate a `.bit` environemnt file containing your publishing address and private key.

```bash
> operate init .
```

You will need to fund your publishing wallet before publishing any Ops. From within your working directory, use the `wallet` command to see your wallet address and balance.

```bash
> operate wallet
```

### Getting help

The CLI can list all available commands and provide usage instructions.

```bash
# List available commands
> operate --help 

# Get help on any command
> operate [command] --help
```

### Creating/publishing functions

Use the `new` command to generate a new blank function in the `src` folder of your working directory.

```bash
> operate new my/function -a arg1 -a arg2
```

### Publish a function

When ready (and your publishing wallet is funded), use the `publish` command to publish the Op to the blockchain.


```bash
> operate publish my/function
```

## Writing Ops

An Op is a function written in Lua. A generated function will look like this:

```lua
--[[
Document the function
]]--
return function(state, arg1, arg2, ...)
  state = state or {}
  -- Code here
  return state
end
```

The first argument of the function is always the `state`. Where a function is called in the first cell of a tape, the state will default to `nil` so your function should handle that.

The function can receive any number of arguments, as defined by your protocol's parameters. Within the body of the function, those arguments can be used to mutate the state in any way before returning a new, modified state.

The comment block immediately prior to the function should be used to add documentation and examples. Any Markdown formatted text can be placed here.

* [Learn more about writing Ops](https://www.operatebsv.org/docs)

## License

[MIT](https://github.com/operate-bsv/op_cli/blob/master/LICENSE.md)

© Copyright 2019 Chronos Labs Ltd.