open-index/open-npm huggingface dataset:
npm package: @octanasoftware/tabler-icons-svelte
Description: Para compilar el proyecto use: ```sh npm run package
Latest version: 1.0.0

Para compilar el proyecto use:
```sh
npm run package

```

Para usarlo en otros proyectos solo use
```sh
npm i <"ruta a esta ruta principal>
```

EN el package.json de su proyecto debe aparecer algo como así: 

```sh
"@octana/tabler-icons-svelte": "file:../../TablerIcons",
```

Y para usarlo use 

```svelte
import {Icon as TablerIcon} from "@octana/tabler-icons-svelte";

<TablerIcon name="user-scan"></TablerIcon>

```

Los ícono tienen el mismo nombre que en la página

https://tabler.io/icons
npm package: @octano/persona
Description: Returns a base persona (name, sex & zodiac) for a given bitcoin or ethereum style address.
Author: iquidus
Latest version: 1.4.0

# Persona

Returns a base persona (name, sex & zodiac) for a given bitcoin or ethereum style address.

As an homage to Satoshi Nakamoto, all names (both given and family) are of a japanese origin.

*Life is for one generation; A good name is forever.*

### Install 

npm:
```
npm install @octano/persona
```

yarn:
```
yarn add @octano/persona
```

### Usage

```javascript
import { getPersona } from '@octano/persona'
const persona = getPersona('0x8429ab69b8721ffb29f2e66fdf06b1c65d66eb58')
console.log(persona)
```

```javascript
{
  success: true,
  sex: 'male',
  name: {
    given: 'Kazufumi',
    family: 'Takeuchi',
  },
  zodiac: 'leo',
  version: 1
}
```

#### Sex

Determined by odd or even state of summed hash: 'male' or 'female'

#### Name

* __given:__ Determined using sex from a total of 512 male and 512 female first names. 
* __family:__ Determined from a total of 4096 last names.

#### Zodiac

one of the following

```javascript
[
  'aquarius',
  'aries',
  'cancer',
  'capricorn',
  'gemini',
  'leo',
  'libra',
  'pisces',
  'sagittarius',
  'scorpio',
  'taurus',
  'virgo',
]
```

#### Error handling

```javascript
import { getPersona } from '@octano/persona'
const persona = getPersona('NOT_A_VALID_ADDRESS')
```

```javascript
{
  success: false,
  error: 'NOT_A_VALID_ADDRESS is not a valid Ubiq/Ethereum address'
}
```

### Usage with NFTs

Persona also supports usage with NFTs

```javascript
import { getPersonaNFT } from '@octano/persona'

const contractAddress = '0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB'
const chainId = 1
const tokenId = 6529

const persona = getPersonaNFT(contractAddress, tokenId, chainId)
console.log(persona)
```

```javascript
{
  success: true,
  sex: 'female',
  name: {
    given: 'Mieko',
    family: 'Kubota',
  },
  zodiac: 'sagittarius',
  version: 1
}
```

#### Match persona sex with NFT

If your NFT already handles sex you can override Persona to match your NFT.

```javascript
import { getPersonaNFT } from '@octano/persona'

const contractAddress = '0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB'
const chainId = 1
const tokenId = 6529
const sex = 'male'

const persona = getPersonaNFT(contractAddress, tokenId, chainId, sex)
console.log(persona)
```

```javascript
{
  success: true,
  sex: 'male',
  name: {
    given: 'Kiyoshi',
    family: 'Kubota',
  },
  zodiac: 'sagittarius',
  version: 1
}
```
npm package: @octantis/option
Description: ![License](https://img.shields.io/github/license/sigmasoldi3r/ts-option.svg)
Author: Pablo Blanco Celdran
Latest version: 1.3.3

# Option ![Typescript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)

![License](https://img.shields.io/github/license/sigmasoldi3r/ts-option.svg)

Optional values are meant to describe a value that is
_explicitly_ present or not.

This makes the presence of the value more clear, in contrast
to making the value nullable (Which will not work if the
compiler is not set to check strictly null values), or
undefined.

As a side effect, makes an optional value capable of holding
a null value, because you might encounter situations where
you want a null value to be a valid one.

## Installation

Run `yarn add @octantis/option` or `npm i @octantis/option`

## API

Option is iterable, in case that the value is present yields
the value.

The option value is meant to mimic Scala's `option[A]` type.

```ts
/**
 * True if not empty
 */
isDefined(): this is Some<A>;
/**
 * Return value, throw exception if empty
 */
get(): A;
/**
 * True if empty
 */
isEmpty(): this is None<A>;
/**
 * True if not empty
 */
nonEmpty(): this is Some<A>;
/**
 * Evaluate and return alternate optional value if empty
 */
orElse(alternative: option<A>): option<A>;
/**
 * Evaluate and return alternate value if empty
 */
getOrElse(alternative: A): A;
/**
 * Apply function on optional value, return default if empty
 */
fold<B>(fallback: B, folder: (value: A) => B): B;
/**
 * Apply a function on the optional value
 */
map<B>(map: (value: A) => B): option<B>;
/**
 * Same as map but function must return an optional value
 */
flatMap<B>(map: (value: A) => option<B>): option<B>;
/**
 * Apply a procedure on option value
 */
forEach(consumer: (value: A) => void): void;
/**
 * Apply partial pattern match on optional value
 */
collect<B>(collector: (value: A) => B | undefined): option<B>;
/**
 * An optional value satisfies predicate
 */
filter(filter: (value: A) => boolean): option<A>;
/**
 * An optional value doesn't satisfy predicate
 */
filterNot(filter: (value: A) => boolean): option<A>;
/**
 * Apply predicate on optional value, or false if empty
 */
exists(predicate: (value: A) => boolean): boolean;
/**
 * Apply predicate on optional value, or true if empty
 */
forAll(predicate: (value: A) => boolean): boolean;
/**
 * Checks if value equals optional value, or false if empty
 */
contains<B extends A>(element: B): boolean;
/**
 * Combine two optional values to make a paired optional value
 */
zip<B>(that: option<B>): option<[A, B]>;
/**
 * Unary list of optional value, otherwise the empty list
 */
toList(): A[];
```

## Example usage

Simplest example:

```ts
// Assume a function
function maybe(): option<number>

let n = maybe()

// This acts as a guard, so now n is of type Some<number>
if (n.isDefined()) {
  console.log(`n = ${n.value}`)
}

// Or at runtime
console.log(`n = ${n.get()}`)
// This throws if the value wasn't present.
```

With iteration:

```ts
for (const value of maybe()) {
  console.log(`value = ${value}`)
}
```
npm package: @octantis/rollerama
Description: A simple template language.
Latest version: 1.0.3-0

# Rollerama

A simple template language.

## Operators

### Pipe operator ->

The pipe operator `L -> R` takes the **L** element and passes it to the **R**
element. The **R** element must be a function.

```scala
// Example
"foo" -> b64
```

**Note:** Not using parenthesis on this operator will pass the functions, as opposed
to the intuition: `a -> b -> c` equivalent to `c(b)(a)` instead to `c(b(a))`. This is
a known [issue #1]().

### Inverse pipe operator <-

The inverse pipe operator `L <- R` is the same as the normal pipe operator, but the
function must be the **L** element.

```scala
// Example
b64 <- "foo"
```

**Note:** This operator has _less_ precedence than `->`, so the expression `a <- b -> c`
is equivalent to `(b -> c) -> a`.

### Map operator >>=

Map operator `L >>= R` takes an iterable element **L** and passes to the **R**
expression, where all the iterable elements are destructured and exposed to the
expression's ambient context.

The input data set:

```js
const data = [{ name: 'John' }, { name: 'Garfield' }, { name: 'Elsa' }]
```

The template:

```scala
// Example
data >>= "{} greets you!"
```

Evaluates to:

```json
["John greets you!", "Garfield greets you!", "Elsa greets you!"]
```

### Join operator +>

The join operator `L +> R` takes an iterable **R** element, and joins it
with the string passed to the **R** element.

Take a dataset like `[1, 2, 3]`, then:

```scala
// Example
data +> "/"
```

Will yield `1/2/3`.

## Literals

### String

Strings are denoted with double quotes `"string"`, and can interpolate
strings inside with curly braces like `{}`.

```scala
// Examples
"Hello world!"
"data = {data -> b64};"
```

### Hamburger

Hamburger operator are used to build objects, to later process them and
serialize to json.

```scala
// Example
(| "Hello": "World!" |) -> json
```

This yields `{"Hello":"World!"}`.

### Number

Numbers are like javascript ones.

## Builtin functions

### b64

### json

### jsonNice
npm package: @octanuary/httpz
Description: HTTPz (http-**easy**) is a lightweight HTTP framework for Node.js.
Author: octanuary
Latest version: 2.0.9

# httpz
HTTPz (http-**easy**) is a lightweight HTTP framework for Node.js.


# Quick Start
To use HTTPz, install it as a dependency in your project, then add some code.

npm:
```
npm install @octanuary/httpz
```

## Example
```js
import httpz from "@octanuary/httpz";

const server = new httpz.Server();

server
	.route("GET", "/", async (req, res) => {
		res.end("Hello World!");
	})
	.listen(5000);
```


# Features

## Routing
HTTPz already comes with a router built-in, which is `httpz.Group`, so you can do this:

```js
import httpz from "@octanuary/httpz";

const server = new httpz.Server();
const group = new httpz.Group();

group.route("GET", "/", (req, res) => {
	res.end("Hello World!");
});

server
	.add(group)
	.listen(5000);
```
npm package: @octaspace/api.js
Description: Package to interact with OctaSpace API
Author: octaspace
Latest version: 1.0.5

## Octaspace API Client Package

### @octaspace/api.js

## Installation

`npm install @octaspace/api.js`

## Usage

### Import necessary classes and functions from the package:

`import { Octa, KeyError, UUIDError, ApiError } from '@octaspace/api.js';`

### Initialize Octa Instance:

`const octa = new Octa('your-api-key');`

Fetch this from Settings of [Cube](https://cube.octa.space/settings) portal.

### Create VPN Service:

Pass type ("wg" or "openvpn") and nodeid (number) as parameter.

`const createdVPN = await octa.createVPN('type', 1);`

Returns UUID

### Get VPN Service Details:

`const vpnDetails = await octa.getVPN('uuid');`

### Stop VPN Service:

`await octa.stopVPN('uuid');`

### Get VPN Node List:

`const vpnNodes = await octa.getVPNNodes();`

### Create MR Service:

Pass image (string), disk size(number), env(optional), and nodeid (number) as parameter.

`const createdMR = await octa.createMR('image', 1, nodeid, {"env1":"value","env2":"value"});`

### Get MR Service Details:

`const mrDetails = await octa.getMR('uuid');`

### Stop MR Service:

`await octa.stopMR('uuid');`

### Get MR Node List:

`const mrNodes = await octa.getMRNodes();`

### Get Account Details:

`const accountDetails = await octa.getAccountInfo();`

### Get Account Balance:

`const accountBalance = await octa.getAccountBalance();`

Note: checkout `lib/src/types.ts` for detail information about what they return.

### Error Handling:

-   `KeyError`: Thrown for issues with the API key. Ex: Wrong API Key
-   `UUIDError`: Thrown for issues with the UUID.
-   `ApiError`: Generic API error. Ex: Due to Network Error
-   `InvalidParameterError`: Invalid Parameter.

## License

MIT License - see LICENSE file for details.
npm package: @octaved-flow/eslint-config
Description: eslint config
Latest version: 1.1.1

# eslint config

_This is a configuration for eslint_

## Usage

Installation with yarn:

```bash
$ yarn add @octaved-flow/eslint-config -D
```

Then create a `.eslintrc` file with the following content:

```json
{
  "extends": "@octaved-flow/eslint-config"
}
```
npm package: @octaved-flow/prettier-config
Description: prettier config
Latest version: 1.2.1

# prettier config

_This is a configuration for prettier_

## Usage

Installation with yarn:

```bash
$ yarn add @octaved-flow/prettier-config -D
```

Then create a `.prettierrc.js` file with the following content:

```js
module.exports = {
  ...require('@octaved-flow/prettier-config'),
  //add overwrites here
};
```
npm package: @octavianlab/olab-ui
Description: Octavianlab UX/UI components
Author: octavianlab
Latest version: 2.0.25

# 🧩 @octavianlab/olab-ui

> A modern and flexible Vue 3 Back Offices UI components library by [Octavian Lab](https://www.octavianlab.com)

![npm version](https://img.shields.io/npm/v/@octavianlab/olab-ui.svg)
![license](https://img.shields.io/npm/l/@octavianlab/olab-ui.svg)
![downloads](https://img.shields.io/npm/dw/@octavianlab/olab-ui.svg)

---

## 🚀 Overview

**olab-ui** is a work-in-progress collection of Vue 3 components designed to accelerate development and unify UI/UX across projects.  
It's built with accessibility, customization, and performance in mind.

> ⚠️ Still in active development — use with caution in production.

---

## 📦 Installation

```bash
npm install @octavianlab/olab-ui
```

Peer dependencies you might need to install:

```bash
npm install vue primevue moment qrcode-vue3 vue3-lottie xlsx
```

---

## ⚙️ Usage

### Globally (recommended)

```ts
// main.js or main.ts
import { createApp } from 'vue';
import App from './App.vue';

import OlabUI from '@octavianlab/olab-ui';
import '@octavianlab/olab-ui/style.css';

const app = createApp(App);
app.use(OlabUI);
app.mount('#app');
```

### Locally

```vue
<script setup>
import { ODropdown, OFiltersPanel } from '@octavianlab/olab-ui';
</script>

<template>
  <ODropdown :options="['A', 'B']" />
</template>
```

---

## 🧱 Components Included

Here are some of the available components (more coming soon):

- `ODropdown`
- `OFiltersPanel`
- `ODialogStoredSearches`
- `OFilter`
- `OCalendar`
- `OTable`
- `ODialog`
- `OChart`
- `OList`
- `OLottie`

_...and many more!_

For a full list of components, see the [`src/components/`](https://github.com/octavian-lab/olab-ui/tree/master/src/components) folder.

---

## 🛠 Development

Clone the repo and run locally:

```bash
npm install
npm run dev
```

To build and generate types:

```bash
npm run generate:dts && npm run build
```

---

## 🤝 Contributing

We welcome contributions!  
Please open issues or submit PRs on the [GitHub repository](https://github.com/octavian-lab/olab-ui).

---

## 📄 License

MIT © [Octavian Lab](https://www.octavianlab.com)

---

## ✨ Maintainers

- [Emanuele Nocentelli](https://www.octavianlab.com) – Octavianlab CEO & Lead Architect
- [Davidz99](https://github.com/Daveedz99) - Frontend Team Leader
- Octavian Lab UI/UX & Frontend Team
npm package: @octavus/core
Description: Public types and utilities for Octavus client/server SDK communication
Author: Octavus AI
Latest version: 2.21.0

# @octavus/core

Shared types and utilities for Octavus SDK communication.

## Installation

```bash
npm install @octavus/core
```

## Overview

This package provides the foundational types and utilities shared between `@octavus/server-sdk` and `@octavus/client-sdk`. Most users won't need to install this package directly—it's automatically included as a dependency of the SDK packages.

## What's Included

### Stream Event Types

Types for all streaming events in Octavus agent communication:

- **Lifecycle events**: `StartEvent`, `FinishEvent`, `ErrorEvent`
- **Text events**: `TextStartEvent`, `TextDeltaEvent`, `TextEndEvent`
- **Reasoning events**: `ReasoningStartEvent`, `ReasoningDeltaEvent`, `ReasoningEndEvent`
- **Tool events**: `ToolInputStartEvent`, `ToolInputAvailableEvent`, `ToolOutputAvailableEvent`, etc.
- **Source events**: `SourceUrlEvent`, `SourceDocumentEvent`
- **Octavus events**: `BlockStartEvent`, `BlockEndEvent`, `ResourceUpdateEvent`, `ToolRequestEvent`, `FileAvailableEvent`

### UI Message Types

Types for rendering agent messages in your application:

```typescript
import type { UIMessage, UIMessagePart, UITextPart, UIToolCallPart } from '@octavus/core';
```

### Error Handling

Structured error types with classification for proper UI handling:

```typescript
import {
  OctavusError,
  isRateLimitError,
  isAuthenticationError,
  isProviderError,
  isToolError,
  isRetryableError,
  isValidationError,
} from '@octavus/core';

// Handle errors based on type
if (isRateLimitError(error)) {
  showRetryUI(error.retryAfter);
} else if (isAuthenticationError(error)) {
  redirectToLogin();
} else if (isValidationError(error)) {
  showValidationError(error.message);
}
```

### Utilities

```typescript
import { generateId, isAbortError, isOtherThread } from '@octavus/core';

// Generate unique IDs
const id = generateId(); // "1702345678901-abc123def"

// Check if error is from abort signal
if (isAbortError(error)) {
  // User cancelled the request
}

// Check if message part belongs to a non-main thread
if (isOtherThread(part)) {
  // Render differently for secondary threads
}
```

### Zod Schemas

Validation schemas for runtime type checking:

```typescript
import { safeParseStreamEvent, safeParseUIMessage } from '@octavus/core';

const result = safeParseStreamEvent(data);
if (result.success) {
  handleEvent(result.data);
}
```

## Related Packages

- [`@octavus/server-sdk`](https://www.npmjs.com/package/@octavus/server-sdk) - Server-side SDK
- [`@octavus/client-sdk`](https://www.npmjs.com/package/@octavus/client-sdk) - Client-side SDK
- [`@octavus/react`](https://www.npmjs.com/package/@octavus/react) - React hooks and bindings

## License

MIT
npm package: @octetstream/invariant
Description: Declarative errors throwing for Node.js
Author: Nick K.
Latest version: 1.2.0

# @octetstream/invariant

Declarative errors throwing for Node.js

[![dependencies Status](https://david-dm.org/octet-stream/invariant/status.svg)](https://david-dm.org/octet-stream/invariant)
[![devDependencies Status](https://david-dm.org/octet-stream/invariant/dev-status.svg)](https://david-dm.org/octet-stream/invariant?type=dev)
[![Build Status](https://travis-ci.org/octet-stream/invariant.svg?branch=master)](https://travis-ci.org/octet-stream/invariant)
[![Code Coverage](https://codecov.io/github/octet-stream/invariant/coverage.svg?branch=master)](https://codecov.io/github/octet-stream/invariant?branch=master)

## API

### `invariant(predicate, error) -> {void}`
  - **boolean** predicate – a result of some condition. Error will threw if predicate is `true`.
  - **object** error – some error object

### `invatiant(predicate, message[, ...format]) -> {void}`

  - **boolean** predicate – a result of some condition. Error will threw if predicate is `true`.
  - **string** message – an error message
  - **any** format – see more about the format in a [sprintf-js documentation](https://github.com/alexei/sprintf.js)

### `invariant(predicate, Error, message[, ...format]) -> {void}`
  - **boolean** predicate – a result of some condition. Error will threw if predicate is `true`.
  - **Function** Error – custom error class that will be used as an error constructor
  - **string** message – an error message
  - **any** format – see more about the format in a [sprintf-js documentation](https://github.com/alexei/sprintf.js)

### `invariant.reject(predicate, message[, ...format]) -> {Promise<void>}`

  Do the same things as `invariant`, but returns Promise that will be rejected when predicate is true.
  This function have same API as `invariant`.

## Example

```js
  import invariant from "@octetstream/invariant"

  // some of your code...

  // Will threw a TypeError if "value" is not a string
  invariant(typeof value !== "string", TypeError, "The value should be a string, but given type is: %s", typeof value)

  invariant(typeof value !== "string", "The value should be a string, but given type is: %s", typeof value)

  invariant(typeof value !== "string", new TypeError(`The value should be a string, but given type is: ${typeof value}`))

  // Will return rejected Promise instead of throw error synchronously
  invariant.reject(typeof value !== "string", TypeError, "The value should be a string, but given type is: %s", typeof value)
    .catch(err => console.error(err))
```
npm package: @octetstream/promisify
Description: Tiny, dependency free promisify library.
Author: Nick K.
Latest version: 2.0.2

# @octetstream/promisify

Tiny, dependency free promisify library.

[![devDependencies Status](https://david-dm.org/octet-stream/promisify/dev-status.svg)](https://david-dm.org/octet-stream/promisify?type=dev)
[![Build Status](https://travis-ci.org/octet-stream/promisify.svg?branch=master)](https://travis-ci.org/octet-stream/promisify)
[![Code Coverage](https://codecov.io/github/octet-stream/promisify/coverage.svg?branch=master)](https://codecov.io/github/octet-stream/promisify?branch=master)

## API

### `promisify(target[, ctx]) -> {Function}`

Promisify Node.js callback-style function with native Promise

  - **{Function}** target - function, that will be wrap with a Promise
  - **{any}** [ctx = null] - "this" context for a target function

### `promisify.all(targets[, ctx]) -> {object}`

Promisify all functions from given object

  - **{object}** targets – object of target functinos
  - **{any}** [ctx = null] - "this" context for all wrapped functions

### `promisify.some(targets, list[, ctx]) -> {object}`

Promisify some functions from given object, that was specified in list

  - **{object}** targets – object of target functinos
  - **{string[]}** list – an array of target functions names
  - **{any}** [ctx = null] - "this" context for all wrapped functions

### `promisify.except(targets, list[, ctx]) -> {object}`

Promisify all functions from given object, except the ones from list

  - **{object}** targets – object of target functinos
  - **{string[]}** list – an array of target functions names
  - **{any}** [ctx = null] - "this" context for all wrapped functions
npm package: @octivas/sdk
Description: Node.js/TypeScript client for the Octivas web scraping and extraction API
Latest version: 0.1.2

# Octivas JavaScript/TypeScript SDK

The official Node.js client for the [Octivas](https://octivas.com) web scraping and extraction API.

## Installation

```bash
npm install @octivas/sdk
# or
yarn add @octivas/sdk
# or
pnpm add @octivas/sdk
```

## Quick start

```typescript
import { Octivas } from "@octivas/sdk";

const client = new Octivas({ apiKey: "oc-..." });

// Scrape a single page
const result = await client.scrape("https://docs.octivas.com");
console.log(result.markdown);

// Crawl a website
const crawl = await client.crawl({ url: "https://docs.octivas.com", limit: 20 });
for (const page of crawl.pages) {
  console.log(page.url, page.metadata?.title);
}

// Search the web
const search = await client.search("python web scraping");
for (const item of search.results) {
  console.log(item.title, item.url);
}
```

## Batch scraping

```typescript
const job = await client.batchScrape({
  urls: ["https://docs.octivas.com", "https://octivas.com"],
});

// Poll until done
const status = await client.batchScrapeWait(job.job_id);
for (const result of status.results) {
  console.log(result.url, result.markdown?.length);
}
```

## Error handling

```typescript
import { Octivas, AuthenticationError, RateLimitError } from "@octivas/sdk";

try {
  const result = await client.scrape("https://docs.octivas.com");
} catch (err) {
  if (err instanceof AuthenticationError) {
    console.error("Invalid API key");
  } else if (err instanceof RateLimitError) {
    console.error("Too many requests - back off and retry");
  }
}
```

## Configuration

```typescript
const client = new Octivas({
  apiKey: "oc-...",
  baseUrl: "https://api.octivas.com", // default
  timeoutMs: 60_000, // default
});
```
npm package: @octoba/framework
Description: Octoba is a modern framework to create awesome Telegram bots.
Author: weijinnx
Latest version: 0.0.2

# Octoba Framework

Before we start I want to create my view of this framework. The main goal is to give for developers a perfect tool to create bots (crud included) for Telegram.
I'm not a pro with NodeJS, but I love Telegram and Telegram bots as well. So, let's dive into framework.

## Requirements

To install and use this tool, you need to stick to these requirements.

# To be continued...
npm package: @october-dev/themes-mcp
Description: MCP server for injecting curated design system themes into AI-generated UI. Makes any AI coding tool produce beautiful, non-generic interfaces.
Latest version: 1.0.0

# October Themes MCP Server

An MCP server that injects curated design system themes into AI-generated UI. Works with Claude, ChatGPT, Cursor, VS Code Copilot, Windsurf, and any tool that supports the Model Context Protocol.

**Stop getting generic-looking AI UI.** This server gives your AI coding tool access to 140+ handcrafted design systems — color palettes, typography, component styles, animations, and bold design rules — so every generated interface has a distinct, polished aesthetic.

## Quick Start

Add to your AI tool — no API key needed, completely free.

**Claude Desktop / Claude Code** — add to `~/.claude/mcp.json`:

```json
{
  "mcpServers": {
    "october-themes": {
      "command": "npx",
      "args": ["-y", "@october-dev/themes-mcp"]
    }
  }
}
```

**Cursor** — add to `.cursor/mcp.json` in your project:

```json
{
  "mcpServers": {
    "october-themes": {
      "command": "npx",
      "args": ["-y", "@october-dev/themes-mcp"]
    }
  }
}
```

**VS Code Copilot** — add to `.vscode/mcp.json`:

```json
{
  "servers": {
    "october-themes": {
      "command": "npx",
      "args": ["-y", "@october-dev/themes-mcp"]
    }
  }
}
```

**Windsurf** — add to `~/.windsurf/mcp.json`:

```json
{
  "mcpServers": {
    "october-themes": {
      "command": "npx",
      "args": ["-y", "@october-dev/themes-mcp"]
    }
  }
}
```

### Use it

Just ask your AI:

- *"Get me a theme for this website"*
- *"Inject a mobile app theme and build the settings screen"*

The AI will call the MCP tools automatically.

## Tools

| Tool | Description |
|------|-------------|
| `get_theme` | Get a weighted-random design system theme, optionally filtered by platform (desktop-web, mobile-app, game). Returns prompt-ready markdown. |
| `get_theme_by_id` | Fetch a specific theme by its ID/slug. |

## How It Works

1. You ask your AI to build UI
2. The AI calls `get_theme` to get a design system
3. The theme (colors, typography, spacing, component styles, animations) becomes part of the AI's context
4. All generated UI follows that design system — no more generic Bootstrap-looking output

Themes are curated by the [October](https://october.dev) team — the AI-native canvas for building apps. Each theme includes:

- Complete color palette (8+ semantic colors with hex values)
- Typography system (fonts, sizes, weights)
- Component styles (buttons, cards, inputs with real Tailwind classes)
- Effects & animations (shadows, gradients, transitions)
- Non-Genericness Rules — mandatory bold design choices that prevent bland output

## Platforms

- **desktop-web** — Websites, dashboards, SaaS apps
- **mobile-app** — iOS/Android apps (includes navigation, safe areas, haptics)
- **game** — Browser games (includes lighting, particles, HUD styling)

## License

MIT

---

Built by [October](https://october.dev) — the AI-native canvas for building apps.
npm package: @october/october-icons
Description: | Icon ID       | | ------------- | |001_bookmark-outline| |002_bookmark| |003_boost-inner| |004_boost-outline| |005_boost| |006_bug-report| |007_champagne| |008_check_rounded| |009_close| |010_color| |011_ellipsis| |012_feed| |013_insert-photo| |014_ligh
Latest version: 0.0.88

# October Icons

| Icon ID       |
| ------------- |
|001_bookmark-outline|
|002_bookmark|
|003_boost-inner|
|004_boost-outline|
|005_boost|
|006_bug-report|
|007_champagne|
|008_check_rounded|
|009_close|
|010_color|
|011_ellipsis|
|012_feed|
|013_insert-photo|
|014_lightbulb|
|016_logo|
|017_navigate-left|
|018_navigate-right|
|019_notification|
|020_obtuse-arrow-down|
|021_obtuse-arrow-right|
|022_partypopper|
|023_person|
|024_search|
|025_streamers|
|026_toggle-text-size|
|027_check|
|028_gallery|
|029_camera|
|030_comments|
|031_dismiss-inner|
|032_dismiss-outline|
|033_dismiss|
|034_check_circle|
|035_comment|
|036_link|
|037_more-horizonal|
|038_more-vertical|
|039_new-post|
|040_star-circle|
|042_write-post|
|043_bold|
|044_italic|
|045_h2|
|046_h3|
|047_list-bullet|
|048_list-number|
|049_paragraph|
|050_quote|
|051_facebook|
|052_hl|
|053_hm|
|054_hs|
|055_arrow-down|
|056_code|
|057_open-in-new|
|058_arrow-left|
|059_arrow-right|
|060_arrow-up|
|061_email|
|062_arrow-drop-down|
|063_high-five|
|064_stats|
|065_arrow-drop-down-outline|
|066_tag|
|067_boost-badge|
|068_bury-badge|
|069_comment-badge|
|070_convert|
|071_settings|
|072_people|
|073_more-chevron|
|074_person-plus|
|075_qr-scan|
|076_rank-up|
|077_rank-down|
|078_more-menu|
|079_downvote|
|080_upvote|
|081_more-menu-simple|
|082_heart|
|083_heart-filled|
|084_heart-badge|
|085_thumbs-up-badge|
|086_thumbs-up-filled|
|087_thumbs-up|
|088_negative-arrow-filled|
|089_negative-arrow-outline|
|090_positive-arrow-filled|
|091_positive-arrow-outline|
|092_composer-prompt|
|093_align-center|
|094_align-left|
|095_align-right|
|096_paragraph-narrow|
|097_paragraph-wide|
|098_text-background|
npm package: @october/slate-md-serializer
Description: [![CircleCI](https://circleci.com/gh/tommoor/slate-md-serializer.svg?style=svg)](https://circleci.com/gh/tommoor/slate-md-serializer)
Latest version: 1.2.1

[![CircleCI](https://circleci.com/gh/tommoor/slate-md-serializer.svg?style=svg)](https://circleci.com/gh/tommoor/slate-md-serializer)

# Slate Markdown Serializer

A Markdown serializer for the [Slate Editor](http://slatejs.org). Requires Slate 0.29+.


## renderMark

This serializer supports the following Slate marks:

```javascript
function renderMark(props) {
  switch (props.mark.type) {
    case 'bold':
      return <strong>{props.children}</strong>;
    case 'code':
      return <Code>{props.children}</Code>;
    case 'italic':
      return <em>{props.children}</em>;
    case 'underlined':
      return <u>{props.children}</u>;
    case 'deleted':
      return <del>{props.children}</del>;
    case 'added':
      return <mark>{props.children}</mark>;
    default:
  }
}
```

## renderNode

This serializer supports the following Slate node keys:

```javascript
function renderNode(props) {
  const { attributes } = props;

  switch (props.node.type) {
    case 'paragraph':
      return <Paragraph {...props} />;
    case 'block-quote':
      return <blockquote {...attributes}>{props.children}</blockquote>;
    case 'bulleted-list':
      return <ul {...attributes}>{props.children}</ul>;
    case 'ordered-list':
      return <ol {...attributes}>{props.children}</ol>;
    case 'todo-list':
      return <ul {...attributes}>{props.children}</ul>;
    case 'table':
      return <table {...attributes}>{props.children}</table>;
    case 'table-row':
      return <tr {...attributes}>{props.children}</tr>;
    case 'table-head':
      return <th {...attributes}>{props.children}</th>;
    case 'table-cell':
      return <td {...attributes}>{props.children}</td>;
    case 'list-item':
      return <li {...attributes}>{props.children}</li>;
    case 'horizontal-rule':
      return <hr />;
    case 'code':
      return <code {...attributes}>{props.children}</code>;
    case 'image':
      return <img src={props.src} title={props.title} />;
    case 'link':
      return <a href={props.href}>{props.children}</a>;
    case 'heading1':
      return <h1 {...attributes}>{props.children}</h1>;
    case 'heading2':
      return <h2 {...attributes}>{props.children}</h2>;
    case 'heading3':
      return <h3 {...attributes}>{props.children}</h3>;
    case 'heading4':
      return <h4 {...attributes}>{props.children}</h4>;
    case 'heading5':
      return <h5 {...attributes}>{props.children}</h5>;
    case 'heading6':
      return <h6 {...attributes}>{props.children}</h6>;
    default:
  }
};
```
npm package: @octoblu/npm-dependents
Description: There's currently no npm command for retrieving a list or count of modules that depend on a given package.
Author: David Mark Clements
Latest version: 2.2.0

# npm-dependents

There's currently no npm command for retrieving
a list or count of modules that depend on a given
package.

This is a useful metric for evaluating a modules
potential usefulness. 

## Install

```sh
[sudo] npm -g install npm-dependents
```

## Usage

```sh

  npm-dependents [module]
  npm-dependents [-l] [--list] [module]
  npm-dependents [-r] [--raw] [module]
  npm-dependents [-h] [--help]

  With no flags, shows a count of all dependents.

  -h | --help Shows usage
  -l | --list List all dependents
  -r | --raw  Show only the count, not surrounding text

  If a module name is not provided the current directory is 
  expected to contain a package.json with a name field, which
  is then used as the module name.

```
npm package: @octoblu/osx-pkg
Description: create mac osx flat packages (.pkg)
Author: Finn Pauls
Latest version: 1.1.0

# osx-pkg
[![NPM](https://nodei.co/npm/osx-pkg.png)](https://nodei.co/npm/osx-pkg/)

Create OSX flat packages (.pkg) with pure JS.

## example

```js
var osxpkg = require('osx-pkg')
var fs = require('fs')

var opts = {
  dir: './root' // the contents of this dir will be installed in installLocation
  installLocation: '/Applications'
  identifier: 'org.myorg.myapp.pkg',
  title: 'MyApp',
  version: '1.0.0'
}

osxpkg(opts)
 .pipe(fs.createWriteStream('Installer.pkg'))
```

The packaging is not done in a complete streaming fashion, but
a temporary folder will be used.

## example with multiple components

```js 
var osxpkg = require('osx-pkg')
var fs = require('fs')

var pkgDir = './out'

fs.mkdirSync(pkgDir)

osxpkg.addComponent(pkgDir, './build/CoolApp.app', {...}, function (err) {
  if (err) return console.error(err)
  osxpkg.addComponent(pkgDir, './build/CoolAppCompanion.app', {...}, function (err) {
    if (err) return console.error(err)
    osxpkg.addDistribution(pkgDir, function (err) {
      if (err) return console.error(err)
      oskpkg.pack(pkgDir).pipe(fs.createWriteStream('Installer.pkg'))
    })
    console.log('DONE')
  })
})


```

## API

## `osxpkg(opts)`

Returns a readable stream that you can read the finished Installer from.


### Options
- `dir` Path to a directory whose contents are going to be installed in installLocation
- `identifier` Identifier for your package, e.g. `org.myorg.myapp.pkg`
- `title` The Title of your package

- `installLocation` (defaults to `/`)
- `tmpDir` The unpackaged pkg will be created here (defaults to a newly created directory in the tmp dir)


## `osxpkg.addComponent(inDir, outDir, opts, cb)`

The final `.pkg` is just a `xar` archived directory with the following structure:
```
Installer.pkg
- Distribution
- component1.pkg
  - Bom
  - Payload
  - PackageInfo
- component2.pkg
  - Bom
  - Payload
  - PackageInfo
- Resources (optional)
```

These components are actually called packages as well. But I am calling them
components to not confuse them with the resulting package...

Given an `inDir` and an `outDir`, this function will package the contents of `inDir`
as a component and add it to `outDir`. So it allows to add multiple components
to an installer before creating the `Distribution` file and finalizing it with `xar`.


## CLI

This modules ships with a CLI:

```
osx-pkg <inputdir>
Packages <inputdir> as an osx flat package to stdout
	options
	--identifier Identifier for your package
	--title Title of your package
	--location Install location (default "/")
  ```

## Modules

You can also create your pkg files by using the components of this modules.
Here are 3 modules that are essential for creating an OSX flat package.

### [cpio-fs](http://npm.im/cpio-fs)

Pack the Payload in the cpio format.

### [mkbom](http://npm.im/mkbom)

Create the Bill of Materials files for the contents

### [xar](http://npm.im/xar)

Flatten the package with xar.
npm package: @octoblu/redis-ns
Description: This module enables you to create Redis namespaces.
Author: Dan Larsen
Latest version: 1.3.1

[![NPM version](https://badge.fury.io/js/redis-ns.png)](http://badge.fury.io/js/redis-ns)

# redis-ns

This module enables you to create Redis namespaces.

Example usage:

	var redis = require('redis');
	var RedisNS = require('redis-ns');

	var redisClient = redis.createClient();

	var client = new RedisNS('MyNameSpace', redisClient);
	var client2 = new RedisNS('MyNameSpace2', redisClient);

	client.set('bla', 'yadda1');
	client.set('bla1', 'yadda1');

	client2.set('bla', 'yadda2');
	client2.set('bla2', 'yadda2');

The above will give you the following keys in Redis:

	"MyNameSpace:bla"
	"MyNameSpace:bla1"
	"MyNameSpace2:bla"
	"MyNameSpace2:bla2"

You can leave out the connection paramater, to create a new connection:

	var client = new RedisNS('MyNameSpace');


### This is an early BETA version

As soon as the module has shown it's worth and stability on a live system, it will be marked as version >= 1.0.0.

Until then: Feel free to play around with it, learn from it.

### To install

	npm install redis-ns


[![Build Status](https://travis-ci.org/octoblu/redis-ns.svg?branch=master)](https://travis-ci.org/octoblu/redis-ns)
[![Code Climate](https://codeclimate.com/github/octoblu/redis-ns/badges/gpa.svg)](https://codeclimate.com/github/octoblu/redis-ns)
[![Test Coverage](https://codeclimate.com/github/octoblu/redis-ns/badges/coverage.svg)](https://codeclimate.com/github/octoblu/redis-ns)
[![npm version](https://badge.fury.io/js/redis-ns.svg)](http://badge.fury.io/js/redis-ns)
[![Gitter](https://badges.gitter.im/octoblu/help.svg)](https://gitter.im/octoblu/help)
npm package: @octod/rescript-react-icons
Description: ``` yarn add react-icons @octod/rescript-react-icons ```
Latest version: 0.0.4

React icons for Rescript
========================

# Install

```
yarn add react-icons @octod/rescript-react-icons
```

Add to your bsconfig.json

```
"dependencies": [
  "@octod/rescript-react-icons"
]
```
npm package: @octod/thestate
Description: A tiny state manager writter in Rescript
Latest version: 0.3.1

Thestate
========

Yet another global state manager.

Yes, it's done with push/sub

Yes, it's simple

Yes, it's made with Rescript

Why chosing it?

- Simple, really simple
- It's made with Rescript! ❤️
- It's very tiny
- Has `.d.ts` files for your js/ts apps
- Built both for commonjs and es6 spec

## install

```bash
yarn add @octod/thestate
```

If you are a js/ts dev, it's done. If you are using rescript (and I recommend it!), add the dependency to your *bsconfig.json* file

```json
"bs-dependencies": [
  "@octod/thestate"
]
```

## creating your first store (rescript)

You have four functions to know: 

- make, creates a store
- getstate, returns a store's value
- mutation, registers a mutation and returns a mutating function
- listen, adds a listener to all mutations in a single store

```rescript
let store = 100->Thestate.make
let increment = store->Thestate.mutation((state, payload) => state + payload)
let unsubscribelistener = store->Thestate.listen(state => Js.Console.log(state))

increment(100) // logs 200
store->Thestate.getstate->Js.Console.log // logs 200

unsubscribelistener()

increment(100) // does not log anymore, we have unsubscribed before
```

## creating your first store (js/ts)

```ts
import * as thestate from 'thestate';

const store = thestate.make(100);
const increment = thestate.mutation(store, (state: number, payload: number) => state + payload);
const unsubscribelistener = thestate.listen(store, console.log);

increment(100) // logs 200
console.log(thestate.getstate(store)) // logs 200

unsubscribelistener()
increment(100) // does not log anymore, we have unsubscribed before
```

## using it with react (rescript)

```rescript
// create your store normally
let store = 100->Thestate.make
// maybe with some mutations is better
let increment = store->Thestate.mutation((state, payload) => state + payload)

module Increment = {
  @react.component
  let make = () => <button onClick={_ => increment(1)}> {"increment"->React.string} </button>
}

module Count = {
  @react.component 
  let make = () => {
    let count = store->Thestate.useState

    <React.Fragment>
      {`current state is ${count->Belt.Int.toString}`->React.string}
    </React.Fragment>
  }
}

module Counter = {
  @react.component
  let make = () => {
    <div>
      <Count />
      <Increment />
    </div>
  }
}
```

## using it with react (js/ts)

```tsx
import React, { useState, useEffect } from 'react';
import * as thestate from '@octod/thestate';

const store = thestate.make(100)
const increment = thestate.mutation(store, (a: number, b: number) => a + b);

const Increment = () => {
  return (
    <button onClick={() => increment(1)}>
      increment
    </button>
  )
}

const Count = () => {
  const count = thestate.useState(store)
  
  return (
    <>{`current state is ${count}`}</>
  )
}

const Counter = () => {
  return (
    <div>
      <Count />
      <Increment />
    </div>
  )
}
```

## Contributions are really welcome

Any kind of contribution is really welcome, so don't be shy!