open-index/open-npm huggingface dataset:
npm package: @onkernel/ai-sdk
Description: Vercel AI SDK-compatible tools for Onkernel Kernel SDK (Playwright execution).
Author: Onkernel
Latest version: 0.0.3

# @onkernel/ai-sdk

Vercel AI SDK-compatible tools for the [Kernel](https://docs.onkernel.com) SDK. This package exposes a Playwright execution tool wired to an existing Kernel browser session, so LLMs can browse and act via structured tools.

## Install

```bash
npm install @onkernel/ai-sdk zod
# Ensure your app depends on the Vercel AI SDK and @onkernel/sdk
npm install ai @onkernel/sdk
```

> Note: `@onkernel/sdk` is a peer dependency; install it in your application.

## Usage

```ts
import { playwrightExecuteTool } from "@onkernel/ai-sdk";
import Kernel from "@onkernel/sdk";
import { generateText } from "ai";

// 1) Create Kernel client and start a browser session
const client = new Kernel({
  apiKey: process.env["KERNEL_API_KEY"], // optional, default env lookup
});
const browser = await client.browsers.create({ browser: "chromium" });
const sessionId = browser.session_id;
console.log(sessionId);

// 2) Create the Playwright execution tool
const playwrightTool = playwrightExecuteTool({ client, sessionId });

// 3) Use with Vercel AI SDK
const model = ...; // your AI model instance

const result = await generateText({
  model,
  prompt: "Open example.com and click the first link",
  tools: {
    playwright_execute: playwrightTool,
  },
});
```

### Tool shape

`playwrightExecuteTool` returns a single Vercel AI SDK tool instance.
The tool's input mirrors `PlaywrightExecuteParams` from the Kernel SDK:

```ts
{
  code: string;        // required JavaScript/TypeScript snippet
  timeout_sec?: number; // optional execution timeout in seconds (default 60)
}
```

Under the hood we call `client.browsers.playwright.execute(sessionId, { code, timeout_sec })`, so any code you can run through the SDK can be run via the tool.

## API

```ts
function playwrightExecuteTool(options: {
  client: Kernel; // Kernel SDK client instance (@onkernel/sdk)
  sessionId: string; // Existing browser session id
}): ReturnType<typeof tool>;
```

## Examples

Run the sample script in `examples/basic.ts` after exporting both `KERNEL_API_KEY`
and a model provider key (the example uses OpenAI):

```bash
export KERNEL_API_KEY=...
export OPENAI_API_KEY=...
pnpm exec tsx examples/basic.ts
```

The script mirrors the usage above: it starts a browser session, registers the
`playwright_execute` tool, calls `generateText` from the Vercel AI SDK (forcing the
model to invoke the tool), logs the model response/tool results, and then cleans up
the browser session.

## License

MIT © Kernel
npm package: @onkz481/solo-ui
Description: Solo UI Components with Vue.js
Author: Kazuya Ono
Latest version: 1.3.6

<p align="center">
  <img alt="SoloUI Logo" width="240" src="https://user-images.githubusercontent.com/97577643/171335757-14237588-446f-40c4-9710-f0e7f28dbd51.png">
</p>


## Install & Usage
Please refer to the documentation for installation and usage.  
[https://solo-ui-document.netlify.app/](https://solo-ui-document.netlify.app/)


## :bookmark_tabs: License
[MIT License](https://opensource.org/licenses/MIT)
npm package: @onlabsorg/olojs-cli
Description: Command line interface for managing olojs libraries
Author: Marcello Del Buono
Latest version: 0.11.0
Deprecated: This package has been moved to @onlabsorg/stilo and it is no longer maintained

# olojs-cli
This is a command line interface for managing [olojs] document packages.
It allows creating a new package, mounting external (local or remote) stores
and serving the documents over HTTP.

### Getting started
Install `olojs-cli` globally.

```
npm install @onlabsorg/olojs-cli -g
```

Initialize a new library:

```
cd /path/to/my-library
olojs init
```

Render a document contained in my-library:

```
olojs render /path/to/doc
```

>   You can optionally inject parameters in the document context by adding them
>   to the command-line
>
>   `olojs render /path/to/doc p1=val1 p2=val2 p3=val3 ...`
>
>   The passed parameters will be added to the document context under the `argns`
>   namespace (argns={p1:val1, p2:val2, p3:val3, ...}).

Serve the library over http:

```
olojs run server
```

Once the HTTP server is running, you can render the library documents in the browser
by visiting the URL `localhost:8010/#/path/to/doc` and optionally pass parameters
via a hash query string (e.g. `localhost:8010/#/path/to/doc?p1=val1;p2=val2`).

For a full description of the commands available, read the
[cli documentation](./docs/cli.md).


### Plugins
Plugins are npm packages that can mount one or more custom stores and/or make
custom commands available to the `olojs run <command>` command.

In order to install a plugin, you use the `install` olojs command, followed
by the name of the npm package that contains the plugin.

```
olojs install plugin-name
```

In order to uninstall a plugin, you use the `uninstall` olojs command, followed
by the name of the npm package that contains the plugin.

> If you are a developer and you want to create your own plugin or customize the
> way a package behaves, check the [package documentation](./package-template/README.md).


### License
[MIT](https://opensource.org/licenses/MIT)


### Related projects

* [olojs] is a content management system based on a distributed network of 
  documents having the following properties.
* [olowiki] is a plugin that allows to render and edit an olojs document package
  in the browser.


[olojs]: https://github.com/onlabsorg/olojs
[olowiki]: https://github.com/onlabsorg/olowiki
npm package: @onlabsorg/olojs-next
Description: A collection of experimental olojs extendsions
Author: Marcello Del Buono
Latest version: 0.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# olojs-next
This library contains a collection of experimental extension of [olojs]. In 
particular, it contains the following packages:

*   `browser-store` is an olojs Store backed by the browser storage
*   `ipfs-store` is a read-only olojs Store that uses [ipfs] as backend
*   `standard-router` is an olojs Router defining a standard directory strucure 
*   `sub-store` is a function that, given a store `s` and a path `p`, returns a
    subordinate olojs Store of `s` where paths `/path` ponts to `/p/path`
*   `olo-atom` is an [atom] plugin that features olojs documents syntax
    highlighting
    
## Getting started
Install `olojs-next` via npm:

```
npm install --save @onlabsorg/olojs-next
```

Load the packages you need:

```js
const StandardRouter = require('@onlabsorg/olojs-next/packages/standard-router');
```

## License
This software is released under the [ISC](https://opensource.org/licenses/ISC) 
license.


[olojs]: https://github.com/onlabsorg/olojs
[ipfs]: https://ipfs.io/
[atom]: https://atom.io/
npm package: @onlabsorg/oloviewer
Description: A HTTP client and Stilo plugin for rendering olojs documents in the browser.
Author: Marcello Del Buono
Latest version: 0.2.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# oloViewer

> This package has been discontinued, since now [olowiki] supports static
> content and can act as a viewer.

This is a web client that renders [olojs] documents in the browser. You can
either use it via the NodeJS API or as a [stilo] plugin.

## Use oloViewer via the NodeJS API 

Install [olojs] and oloViewer via npm:

```sh
npm install @onlabsorg/olojs
npm install @onalbsorg/oloviewer
```

Create an [olojs] store to be serverd:

```js
olo = require('@onlabsorg/olojs');
store = new olo.FileStore(`/path/to/home`);
```

Create and start an oloViewer server:

```js
{Server} = require('@onlabsorg/oloviewer');
server = Server(store);
server.listen(8010);
```


## Use oloViewer as stilo plugin
Install [stilo] and initialize a repository:

```sh
npm install -g @onlabsorg/stilo 
cd /path/to/home
stilo init
``` 

Install and start the viewer plugin:

```sh
stilo install @onlabsorg/oloviewer
stilo run viewer
```


## Render a document in the browser
Once you have an oloViewer server listening (say to port 8010), you can render 
the documents of the served store in the browser at the following URL:

```
http://localhost:8010/#/path/to/doc
```

Optionally you can pass a query string after the path (e.g. 
`#/path/to/doc?key1=val1&key2=val2&key3=val2`). In that case, the keys-value 
pairs contained in the query string will be available to the document scope 
under the `__query__` namespace.


## License
This software is released under the [MIT](https://opensource.org/licenses/MIT) 
license.


## Related projects
* [stilo] is a command-line interface written in NodeJS that allows you to
  create and mange local olojs document repositories.
* [olojs] is a distributed content management system


[olojs]: https://github.com/onlabsorg/olojs/blob/master/README.md
[stilo]: https://github.com/onlabsorg/stilo/blob/main/README.md
[olowiki]: https://github.com/onlabsorg/olowiki/blob/main/README.md
npm package: @onlabsorg/swan-js
Description: A simple yet powerful expression language written in JavaScript
Author: Marcello Del Buono
Latest version: 0.13.0

SwanJS
================================================================================
SwanJS is an expression language that runs in any JavaScript environment.

```js
swan = require('swan-js');              // load the library
evaluate = swan.parse( "3 * x" );       // compile an expression
context = swan.createContext({x:10});   // create an expression context
value = await evaluate(context);        // evaluate expression in context: 30
```

You can install SwanJS via npm:

```
npm install @onlabsorg/swan-js
```


Syntax
--------------------------------------------------------------------------------

A Swan expression is simply a sequence of binary operations
(operand operator operand operator operand ...), eventually grouped with
parentheses (...), square braces [...] or curly braces {...}.

The available binary operations are:

- Arithmetic operations: `x + y`, `x - y`, `x * y`, `x / y`, `x % y`, `x ^ y`
- Comparison operations: `x == y`, `x != y`, `x > y`, `x >= y`, `x < y`, `x <= y`
- Logic operations: `x & y`, `x | y`
- Conditional and alternative operations: `x ? y`, `x ; y`, or combined `x ? y ; z`
- Pairing operation: `x , y`
- Application (function call): `x y`
- Function definition: `x -> y`
- Composition operations: `g << f`, `f >> g`
- Mapping operation: `x => f`
- Assignment operations: `name = x`, `name: x`
- Sub-contexting operation: `x.y`

The types of grouping available are:

- Parentheses to alter evaluation precedence: `(expr)`
- Square braces to create lists: `[x1, x2, x3, ...]`
- Curly braces to create namespaces: `{n1:v1, n2=v2, n3:v3, ...}`

The data types defined in swan are:

- Nothing, or empty tuple: `()`
- Bool: `TRUE`, `FALSE`
- Numb: `123.4`
- Text: `"abc"`, `'abc'`, `` `abc` ``
- List: `[a, b, c, ...]`
- Namespace: `{n1:v1, n2=v2, n3=v3, ...}`
- Func: `names -> expression`
- Undefined: `undefined(operationName, operands)`
- Tuple: `x1, x2, x3, ...`

Besides these operations, Swan defines also some essential [builtins](./docs/builtins.md),
consisting in functions constants.


Learn more
--------------------------------------------------------------------------------
- [Swan expression language guide](./docs/swan.md)
- [Swan standard modules](./docs/modules/index.md)
- [JavaScript API](./docs/api.md)
- [Swan REPL](./docs/repl.md)


License
--------------------------------------------------------------------------------
[MIT](https://opensource.org/licenses/MIT)


Related projects
--------------------------------------------------------------------------------
- [olojs](https://github.com/onlabsorg/olojs) is a template engine and
  content management system that uses swan as inline expression language
npm package: @onlaw/eslint-config
Description: Onlaw's ESLint config
Latest version: 4.0.0

# @onlaw/eslint-config

## Install

Install the package

```sh
yarn add -D eslint @onlaw/eslint-config
```

and add it to your `.eslintrc.json`:

```json
{
  "root": true,
  "extends": ["@onlaw/eslint-config"]
}
```
npm package: @onlaw/node
Description: Onlaw's node client is a simple utility that can help authenticating with the API and getting a valid JWT.
Latest version: 1.0.1

# @onlaw/node

Onlaw's node client is a simple utility that can help authenticating with the API and getting a valid JWT.

## Installation

Install the package

```sh
yarn add @onlaw/node
```

## Use

### Example

```js
import { Onlaw } from '@onlaw/node'
import fetch from 'node-fetch'

const onlaw = new Onlaw({
  id: '',
  secret: '',
})

//
;(async () => {
  const token = await onlaw.getToken()

  try {
    const { data } = await fetch('https://api.onlaw.dk/graphql', {
      body: JSON.stringify({
        query: `mutation {
          link(html: "HTML") {
            id
          }
        }`,
      }),
      headers: {
        Authorization: `Bearer ${token.access_token}`,
      },
      method: 'post',
    })

    console.dir(data)
  } catch (error) {
    console.log(error)
  }
})()
```