open-index/open-npm huggingface dataset:
npm package: @morphic-ai/chartjs-plugin-streaming
Description: Chart.js plugin for live streaming data
Author: Akihiko Kusanagi
Latest version: 3.2.0

<p align="center">
  <img src="docs/.vuepress/public/logo.svg" style="width: 300px;">
</p>

# chartjs-plugin-streaming

[![npm](https://img.shields.io/npm/v/chartjs-plugin-streaming.svg?style=flat-square)](https://www.npmjs.com/package/@robloche/chartjs-plugin-streaming) [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/nagix/chartjs-plugin-streaming/CI?style=flat-square)](https://github.com/robloche/chartjs-plugin-streaming/actions?query=workflow%3ACI+branch%3Amaster) [![Code Climate](https://img.shields.io/codeclimate/maintainability/nagix/chartjs-plugin-streaming.svg?style=flat-square)](https://codeclimate.com/github/nagix/chartjs-plugin-streaming) [![Awesome](https://awesome.re/badge-flat2.svg)](https://github.com/chartjs/awesome)

*[Chart.js](https://www.chartjs.org) plugin for live streaming data*

Forked from https://github.com/nagix/chartjs-plugin-streaming because it appears to be unmaintained.

chartjs-plugin-streaming 3.x requires Chart.js 4.1.1 or later. If you need Chart.js 2.x support, use the following versions.

- For Chart.js 2.9.x, 2.8.x or 2.7.x, use [version 1.9.0](https://github.com/nagix/chartjs-plugin-streaming/releases/tag/v1.9.0) ([tutorials](https://nagix.github.io/chartjs-plugin-streaming/1.9.0/) and [samples](https://nagix.github.io/chartjs-plugin-streaming/1.9.0/samples/))
- For Chart.js 2.6.x, use [version 1.2.0](https://github.com/nagix/chartjs-plugin-streaming/releases/tag/v1.2.0)
- For Chart.js 4.x, use [version 3.0.0](https://github.com/Robloche/chartjs-plugin-streaming)

## Documentation

- [Introduction](https://nagix.github.io/chartjs-plugin-streaming/master/guide/)
- [Getting Started](https://nagix.github.io/chartjs-plugin-streaming/master/guide/getting-started.html)
- [Options](https://nagix.github.io/chartjs-plugin-streaming/master/guide/options.html)
- [Data Feed Models](https://nagix.github.io/chartjs-plugin-streaming/master/guide/data-feed-models.html)
- [Integration](https://nagix.github.io/chartjs-plugin-streaming/master/guide/integration.html)
- [Performance](https://nagix.github.io/chartjs-plugin-streaming/master/guide/performance.html)
- [Migration](https://nagix.github.io/chartjs-plugin-streaming/master/guide/migration.html)
- [Tutorials](https://nagix.github.io/chartjs-plugin-streaming/master/tutorials/)
- [Samples](https://nagix.github.io/chartjs-plugin-streaming/master/samples/)

## Development

You first need to install node dependencies (requires [Node.js](https://nodejs.org/)):

```bash
npm install
```

The following commands will then be available from the repository root:

```bash
npm run build      # build dist files
npm run build:dev  # build and watch for changes
npm run lint       # perform code linting
npm run package    # create an archive with dist files
npm run docs       # generate documentation (`dist/docs`)
npm run docs:dev   # generate documentation and watch for changes
```

## License

chartjs-plugin-streaming is available under the [MIT license](https://opensource.org/licenses/MIT).
npm package: @morphika/andami
Description: Visual Page Builder — core library. A reusable website builder with visual editing, CMS integration, and asset management.
Latest version: 0.2.5

# @morphika/andami

A reusable Visual Page Builder framework for Next.js. Build custom websites with a drag-and-drop visual editor, Sanity CMS backend, and zero-config deployment.

**Designed for Vercel Hobby tier** — the framework is engineered to run comfortably within Vercel's free/Hobby plan limits (4h Fluid Active CPU, 10 GB Fast Origin Transfer per month). Aggressive ISR caching, Sanity CDN routing, bot mitigation, and Edge-first middleware keep serverless CPU usage minimal even under crawler traffic.

## Features

- **Visual Page Builder** — Infinite canvas editor with device previews (desktop, tablet, phone)
- **9 Content Blocks** — Text, Image, Image Grid, Video, Spacer, Button, Cover, Project Grid, Parallax
- **V2 Grid System** — 12-column CSS grid with push cascade engine and responsive overrides
- **Custom Sections** — Create reusable sections with per-instance setting overrides
- **Navigation Builder** — Visual 12-column grid editor with drag & drop
- **Animation System** — Enter animations, hover effects (CSS + WebGL shaders), page transitions
- **Asset Management** — Cloudflare R2 storage with browser, thumbnails, and CDN serving
- **Setup Wizard** — Guided onboarding for new sites
- **Sanity v3 CMS** — Structured content with custom schemas, GROQ queries, and ISR
- **Vercel-Optimized** — Sanity CDN for public queries, 24h ISR, R2 direct CDN shortcut, bot guard middleware, aggressive robots.txt with crawl-delay — all tuned to minimize serverless CPU on Hobby tier

## Quick Start

```bash
npx create-andami-site my-site
cd my-site
npm install
npm run dev
```

Visit `http://localhost:3000/admin` to start building.

## Stack

Next.js 16 (App Router) · Sanity v3 · Tailwind CSS v4 · Zustand · @dnd-kit · TypeScript

## Documentation

| Doc | Description |
|-----|-------------|
| [Getting Started](docs/GETTING-STARTED.md) | 5-minute quickstart |
| [Configuration](docs/CONFIGURATION.md) | `site.config.ts` reference |
| [Architecture](docs/ARCHITECTURE.md) | Technical architecture and data flow |
| [Blocks](docs/BLOCKS.md) | All block types with fields and options |
| [Builder](docs/BUILDER.md) | Page builder UI, interactions, store |
| [CMS](docs/CMS.md) | Sanity schemas and GROQ queries |
| [Assets](docs/ASSETS.md) | Storage, providers, thumbnails |
| [Customization](docs/CUSTOMIZATION.md) | Custom blocks, fonts, styles |
| [Deployment](docs/DEPLOYMENT.md) | Vercel, domains, R2 setup |
| [Publishing](docs/PUBLISHING.md) | npm package publishing workflow |
| [Development](docs/DEVELOPMENT.md) | Framework + instance dev workflow |

## License

MIT
npm package: @morphika/webframe
Description: Visual Page Builder — core library. A reusable website builder with visual editing, CMS integration, and asset management.
Latest version: 0.1.2

# @morphika/webframe

Core library for the **Visual Page Builder** — a reusable website builder built on Next.js and Sanity.

## Quick Start

```bash
npx create-visual-builder my-site
cd my-site
npm run dev
```

Then open `http://localhost:3000/admin` to run the setup wizard.

## What's Included

- Visual page builder with drag-and-drop sections, columns, and blocks
- 7 content block types (text, image, image grid, video, spacer, button, cover)
- Project grid with masonry layout
- Parallax scroll sections
- Custom reusable sections
- Navigation builder (12-column grid)
- Asset management with Cloudflare R2 storage
- Enter animations, hover effects, and page transitions
- Global styles editor (typography, colors, grid)
- Responsive design with desktop/tablet/phone viewports
- SEO metadata per page
- Sanity CMS backend

## Documentation

- [Getting Started](https://github.com/MorphikaStudio/morphika-web-builder/blob/main/docs/GETTING-STARTED.md)
- [Configuration Reference](https://github.com/MorphikaStudio/morphika-web-builder/blob/main/docs/CONFIGURATION.md)
- [Customization Guide](https://github.com/MorphikaStudio/morphika-web-builder/blob/main/docs/CUSTOMIZATION.md)
- [Deployment Guide](https://github.com/MorphikaStudio/morphika-web-builder/blob/main/docs/DEPLOYMENT.md)

## Requirements

- Node.js 22+
- Next.js 16+
- React 19+
- Sanity v3 project

## License

MIT
npm package: @morphis-labs/eslint-config
Description: morphis public eslint configuration
Author: Morphis Labs
Latest version: 1.0.9

# @morphis-labs/eslint-config [![NPM version](https://img.shields.io/npm/v/@morphis-labs/eslint-config.svg)](https://www.npmjs.com/package/@morphis-labs/eslint-config)

> ESLint [shareable config](http://eslint.org/docs/developer-guide/shareable-configs.html) by [Morphis Labs](https://morphis.network).

## Install

```shell
npm install --save-dev @morphis-labs/eslint-config
yarn install -D @morphis-labs/eslint-config
pnpm install -D @morphis-labs/eslint-config
```

## Usage

Create an `.eslintrc` file:

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

Or add the ESLint config to your `package.json`:

```json
{
  "name": "my-awesome-project",
  "eslintConfig": {
    "extends": "@morphis-labs/eslint-config"
  }
}
```
npm package: @morphis-labs/prettier-config
Description: morphis public prettier configuration
Author: Morphis Labs
Latest version: 0.0.2

# @morphis-labs/prettier-config [![NPM version](https://img.shields.io/npm/v/@morphis-labs/prettier-config.svg)](https://www.npmjs.com/package/@morphis-labs/prettier-config)

Morphis [shareable config](https://prettier.io/docs/en/configuration.html#sharing-configurations) for [Prettier](https://prettier.io/)

## Installation

Install Prettier and `@morphis-labs/prettier-config`:

```
npm install --save-dev prettier @morphis-labs/prettier-config
yarn install prettier @morphis-labs/prettier-config
pnpm add prettier @morphis-labs/prettier-config
```


## How to use
To enable `@morphis-labs/prettier-config` rules, add a `prettier` property in your `package.json`. See the [Prettier configuration docs](https://prettier.io/docs/en/configuration.html) for more details.

```json
"prettier": "@morphis-labs/prettier-config"
```

If you don't want to use `package.json`, you can use any of the supported extensions to export a string:

```jsonc
// `.prettierrc.json`
"@morphis-labs/prettier-config"
```

```javascript
// `prettier.config.js` or `.prettierrc.js`
module.exports = '@morphis-labs/prettier-config';
```

## Extending

This configuration is not intended to be changed, but if you have a setup where modification is required, it is possible. Prettier does not offer an "extends" mechanism as you might be familiar from tools such as ESLint.

To extend a configuration you will need to use a `prettier.config.js` or `.prettierrc.js` file that exports an object:

```javascript
module.exports = {
    ...require('@morphis-labs/prettier-config'),
    semi: false
};
```

## [LICENSE](LICENSE)
npm package: @morphis-labs/tsconfig
Description: morphis public tsconfig
Author: Morphis Labs
Latest version: 0.0.2

# tsconfig

> Public [TypeScript config](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) by Morphis Labs

## Install

```sh
npm install --save-dev @morphis-labs/tsconfig
yarn add -D @morphis-labs/tsconfig
pnpm add -D @morphis-labs/tsconfig
```

_This config requires TypeScript 4.7 or later._

## Usage

`tsconfig.json`

```json
{
  "extends": "@morphis-labs/tsconfig",
  "compilerOptions": {
    "outDir": "custom_dir_you_want"
  },
  "include": ["custom/directory/you/want"]
}
```

When you are targeting a higher version of Node.js, check the relevant ECMAScript version and add it as `target`:

```json
{
  "extends": "@morphis-labs/tsconfig",
  "compilerOptions": {
    "outDir": "dist",
    "target": "ES2021"
  }
}
```
npm package: @morphism-labs/core-utils
Description: `@morphism-labs/core-utils` contains the Morphism Virtual Machine core utilities.
Author: Morphism
Latest version: 0.0.1

# @morphism-labs/core-utils
## What is this?

`@morphism-labs/core-utils` contains the Morphism Virtual Machine core utilities.

## Getting started

### Building and usage

After cloning and switching to the repository, install dependencies:

```bash
$ yarn
```

Use the following commands to build, use, test, and lint:

```bash
$ yarn build
$ yarn test
$ yarn lint
```

### L2 Fees

`TxGasLimit` can be used to `encode` and `decode` the L2 Gas Limit
locally.

```typescript
import { TxGasLimit } from '@morphism-labs/core-utils'
import { JsonRpcProvider } from 'ethers'

const L2Provider = new JsonRpcProvider('http://127.0.0.1:9545')
const L1Provider = new JsonRpcProvider('http://127.0.0.1:8545')

const l2GasLimit = await L2Provider.send('eth_estimateExecutionGas', [tx])
const l1GasPrice = await L1Provider.getGasPrice()

const encoded = TxGasLimit.encode({
  data: '0x',
  l1GasPrice,
  l2GasLimit,
  l2GasPrice: 10000000,
})

const decoded = TxGasLimit.decode(encoded)
assert(decoded.eq(gasLimit))

const estimate = await L2Provider.estimateGas()
assert(estimate.eq(encoded))
```
npm package: @morphism-systems/agentic-math
Description: Category theory MCP server — morphisms, functors, natural transformations, convergence
Latest version: 0.1.7

# @morphism-systems/agentic-math

[![npm](https://img.shields.io/npm/v/@morphism-systems/agentic-math)](https://www.npmjs.com/package/@morphism-systems/agentic-math)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE-MIT)

Category theory MCP server for AI agents. Morphism composition, functor mapping, natural transformations, entropy computation, and convergence checking.

## About

A standalone MCP server that exposes category theory operations to AI assistants. Compose morphisms, map functors, check naturality conditions, compute Shannon entropy, and verify convergence -- all through structured tool calls. Free to use with any MCP-compatible client.

## Installation

```bash
npx @morphism-systems/agentic-math
```

## Quick Start

Add to your `.claude/mcp.json` or Cursor MCP settings:

```json
{
  "mcpServers": {
    "morphism-math": {
      "command": "npx",
      "args": ["@morphism-systems/agentic-math"]
    }
  }
}
```

## Tools

| Tool | Description |
|------|-------------|
| `morphism_compose` | Compose two morphisms f . g |
| `functor_map_object` | Apply a functor to an object |
| `functor_map_morphism` | Apply a functor to a morphism |
| `natural_transform_check` | Check naturality condition |
| `natural_transform_compose` | Vertical composition of natural transformations |
| `entropy_compute` | Shannon entropy H(s) = -sum(p_i ln(p_i)) |
| `convergence_check` | Check if governance converges (kappa < 1) |
| `drift_check` | Compute drift delta between states |
| `analyze_scores` | Full governance score analysis |

## Example Output

```jsonc
// Tool: morphism_compose
// Input: { "f": { "name": "g", "source": "B", "target": "C" },
//          "g": { "name": "f", "source": "A", "target": "B" } }
// Output:
{ "name": "g . f", "source": "A", "target": "C" }

// Tool: entropy_compute
// Input: { "values": [0.9, 0.8, 1.0, 0.7, 1.0, 0.95, 0.85] }
// Output:
{ "entropy": 0.42, "normalized": true }
```

## Documentation

Full reference: [https://morphism-systems.github.io/morphism/](https://morphism-systems.github.io/morphism/)

## License

[MIT](../../LICENSE-MIT)
npm package: @morphism-systems/cli
Description: Morphism governance CLI — init, validate, score, doctor
Latest version: 0.2.0

# @morphism-systems/cli

[![npm](https://img.shields.io/npm/v/@morphism-systems/cli)](https://www.npmjs.com/package/@morphism-systems/cli)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE-MIT)

Governance CLI for AI-assisted engineering. Validate repos, compute maturity scores, detect drift, and set up MCP integration.

## About

The Morphism CLI gives you governance checks in your terminal. Initialize a repo with `morphism init`, validate against governance rules, compute maturity scores, and detect drift -- all without leaving your development workflow. Free tier includes all core commands; Team and Enterprise tiers unlock diff, proof, and auto-healing.

## Installation

```bash
npm install -g @morphism-systems/cli
```

## Quick Start

```bash
morphism setup              # Install MCP server and configure IDE integration
morphism init --tenets 10   # Scaffold .morphism/ with 10 governance tenets
morphism validate           # Run governance validation (kappa, delta, violations)
morphism doctor             # Check AGENTS.md, SSOT.md, Python, and scripts
```

## Commands

### Free tier

| Command | Description |
|---------|-------------|
| `setup` | Install MCP server and configure IDE integration |
| `init` | Scaffold `.morphism/config.json` and governance files |
| `validate` | Run governance validation pipeline |
| `doctor` | Check environment and governance prerequisites |
| `score` | Compute maturity score breakdown (0–125) |
| `status` | Show current governance status |
| `scaffold` | Generate governance file templates |
| `entropy` | Measure, compare, and report entropy |
| `policy` | Check and list policy violations |
| `plugin` | List, install, remove, and search plugins |
| `learn` | Summarize rules and pairs from the learning store |
| `sync-registry` | Sync the unified governance registry |

### Team tier

| Command | Description |
|---------|-------------|
| `diff` | Diff governance state between two refs |
| `proof` | Query proof witnesses from governance runs |

### Enterprise tier

| Command | Description |
|---------|-------------|
| `heal` | Preview auto-remediation actions |
| `heal --apply` | Apply auto-remediation to detected drift |

## Example Output

```
$ morphism validate
κ = 0.0000 | δ = 0.0000
Maturity: converged | Converging: true
Violations: 0
Governance validation: PASS

$ morphism score
  governance_docs: 15/15
  ci_coverage: 15/15
  hook_coverage: 10/10
  ssot_atoms: 15/15
  security_gates: 15/15
  docs_completeness: 10/10
  adr_history: 5/5
  runbook_coverage: 5/5
  automation_bots: 10/10
  frontmatter_coverage: 5/5
  test_coverage: 10/10
  convergence_health: 10/10
  total: 125/125
```

## Documentation

Full reference: [https://morphism-systems.github.io/morphism/](https://morphism-systems.github.io/morphism/)

## License

[MIT](../../LICENSE-MIT)
npm package: @morphism-systems/mcp-server
Description: Governance MCP server — validation, maturity scoring, convergence and drift metrics
Latest version: 0.1.15

# @morphism-systems/mcp-server

[![npm](https://img.shields.io/npm/v/@morphism-systems/mcp-server)](https://www.npmjs.com/package/@morphism-systems/mcp-server)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE-MIT)

Governance MCP server for AI agents. Expose governance validation, convergence metrics, drift detection, and proof witnesses to Claude, Cursor, and other MCP clients.

## About

An MCP (Model Context Protocol) server that gives AI coding assistants access to governance tools. Add it to Claude Code, Cursor, or any MCP-compatible client and your AI assistant can validate repos, compute convergence metrics, measure entropy, and query proof witnesses. Free tier tools are available to all users; Pro, Team, and Enterprise tools require a paid plan.

## Installation

```bash
npx @morphism-systems/mcp-server
```

## Quick Start

Add to your `.claude/mcp.json` (or Cursor MCP settings):

```json
{
  "mcpServers": {
    "morphism-governance": {
      "command": "npx",
      "args": ["@morphism-systems/mcp-server"]
    }
  }
}
```

## Tools

| Tool | Description | Tier |
|------|-------------|------|
| `governance_validate` | Run full governance validation pipeline | Free |
| `governance_score` | Compute maturity score (0–125) | Free |
| `compute_kappa` | Convergence metric (κ → 0 = healthy) | Pro |
| `compute_delta` | Drift metric between governance states | Pro |
| `entropy_measure` | Measure entropy of governance artifacts | Pro |
| `governance_diff` | Diff governance state between two refs | Pro |
| `ssot_verify` | Verify SSOT integrity across all atoms | Team |
| `governance_heal` | Auto-remediate detected drift | Enterprise |

## Example Output

```jsonc
// Tool: governance_score
// Input: { "project_path": "/path/to/your/project" }
// Output:
{
  "score": 124,
  "max": 125,
  "level": "optimizing"
}

// Tool: compute_kappa
// Input: { "governance_vector": [1, 1, 1, 1, 1, 1, 1] }
// Output:
{
  "kappa": 0,
  "converging": true,
  "method": "vector_linf_formal",
  "interpretation": "Fixed point: governance is fully compliant"
}
```

## Documentation

Full reference: [https://morphism-systems.github.io/morphism/](https://morphism-systems.github.io/morphism/)

## License

[MIT](../../LICENSE-MIT)
npm package: @morphism-systems/sdk
Description: Embeddable governance SDK — run Morphism categorical governance checks from any platform
Latest version: 0.1.1

# @morphism-systems/sdk

[![npm](https://img.shields.io/npm/v/@morphism-systems/sdk)](https://www.npmjs.com/package/@morphism-systems/sdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE-MIT)

Embeddable governance SDK. Run governance checks -- kappa computation, drift detection, validation, and proof witness queries -- from any TypeScript/JavaScript platform.

## About

Embed Morphism governance checks into your own tools, CI pipelines, or platforms. The SDK provides a typed client with methods for convergence computation, drift detection, validation, and proof witness queries. Ships as both ESM and CJS. Requires a Pro plan or above.

> **Note:** The REST API (`https://api.morphism.systems`) is in development. The SDK currently supports local MCP-based governance.

## Installation

```bash
npm install @morphism-systems/sdk
```

## Quick Start

```typescript
import { MorphismClient } from '@morphism-systems/sdk'

const client = new MorphismClient({
  credential: process.env.MORPHISM_API_KEY!,
})

// Full governance check with pass/fail verdict
const result = await client.runGovernanceCheck()

if (result.pass) {
  console.log(`Governance check passed (kappa=${result.kappa.toFixed(4)})`)
} else {
  console.log(`Governance check failed: ${result.drift_count} drift items`)
  for (const item of result.drift_items) {
    console.log(`  [${item.severity}] ${item.file}: ${item.description}`)
  }
}
```

## What's included

| Method | Description |
|--------|-------------|
| `runGovernanceCheck()` | Compose all checks into a single pass/fail verdict |
| `computeKappa()` | Convergence metric (κ → 0 = fully compliant) |
| `checkDrift()` | Detect drift items with severity and file location |
| `validate()` | Run validation pipeline, return violations list |
| `getProofWitnesses()` | Query proof witnesses from governance runs |

## CI/CD gate

```typescript
const result = await client.runGovernanceCheck({
  kappa_threshold: 0.5,   // Fail if kappa >= 0.5
  max_drift_items: 3,     // Fail if more than 3 drift items
})

process.exit(result.pass ? 0 : 1)
```

## Pass/fail logic

`runGovernanceCheck()` composes individual checks into a single verdict:

1. **Kappa threshold** — kappa must be below threshold (default: 1.0, meaning convergent)
2. **Drift limit** — drift item count must be within limit (default: unlimited)
3. **High-severity drift** — any high-severity drift item auto-fails
4. **Validation errors** — any error-level violation auto-fails

## Documentation

Full reference: [https://morphism-systems.github.io/morphism/](https://morphism-systems.github.io/morphism/)

## License

[MIT](../../LICENSE-MIT)
npm package: @morphism/fp
Description: @morphism/fp
Latest version: 0.4.0

# @morphism/fp

A faithful re-export of [fp-ts](https://github.com/gcanti/fp-ts) that uses declaration merging to
allow access to both a type _and_ all methods on that type,
using only a single import statement.


### Examples

Here's an example using `TaskEither` from `fp-ts`:
```typescript
import { TaskEither } from "fp-ts/lib/TaskEither"
import * as TE from "fp-ts/lib/TaskEither"

const instance: TaskEither<E, A> = ...

pipe(
  instance,
  TE.chain(...),
  TE.map(...),
  TE.fold(
    (e: E) => ...,
    (a: A) => ...
  )
)
```

The equivalent using `TaskEither` from `@morphism/fp`:
```typescript
import { TaskEither } from "@morphism/fp"

const instance: TaskEither<E, A> = ...

pipe(
  instance,
  TaskEither.chain(...),
  TaskEither.map(...),
  TaskEither.fold(
    (e: E) => ...,
    (a: A) => ...
  )
)
```

<br/>

Here's another example using `Either` from `fp-ts`:
```typescript
import { Either } from "fp-ts/lib/Either"
import * as E from "fp-ts/lib/Either"

const instance: Either<E, A> = ...

pipe(
  instance,
  E.chain(...),
  E.map(...),
  E.fold(
    (e: E) => ...,
    (a: A) => ...
  )
)
```

The equivalent using `Either` from `@morphism/fp`:

```typescript
import { Either } from "@morphism/fp"

const instance: Either<E, A> = ...

pipe(
  instance,
  Either.chain(...),
  Either.map(...),
  Either.fold(
    (e: E) => ...,
    (a: A) => ...
  )
)
```
npm package: @morphism/runtime
Description: @morphism/runtime
Latest version: 0.1.9

# @morphism/runtime

A combination of [io-ts](https://github.com/gcanti/io-ts) and [io-ts-types](https://github.com/gcanti/io-ts-types), exported under
a namespace called `Runtime`, that acts as an all-in-one input/output
validation library.

<br/>

### Examples

If we have an endpoint that accepts a payload of the following shape:
```typescript
{
  username: string;
  hoursWorked: string;
  isOvertime?: string;
  date: number
}
```
and, after parsing/validation, needs to be transformed to:
```typescript
{
  username: string;
  hoursWorked: number;
  isOvertime: boolean;
  date: Date
}
```
where 
- `username` is a required parameter that we want a special error message for 
- `isOvertime` is an optional argument we want to fill with a default value when
it isn't provided
- `date` is a UNIX epoch representing a `Date`
- `hoursWorked` is just some number

Then we could use `@morphism/runtime` to describe the above logic like so:
```typescript
import { Runtime } from "@morphism/runtime";

type Request = Runtime.ToType<typeof runtime>;
namespace Request {
  export const runtime = () =>
    Runtime.strict({
      username: Runtime.withMessage(
        Runtime.string(),
        () => 'Some special error message for just username'
      ),
      hoursWorked: Runtime.numberFromString(),
      isOvertime: Runtime.withFallback(Runtime.booleanFromString(), false),
      dateRange: Runtime.dateFromUnixTime(),
    });
}
```
`Request` now represents the shape our `Request.runtime` function validates,
and can be used like so:
```typescript
pipe(
  input,
  Request.runtime().decode,
  Either.fold(
    (errors: Runtime.Errors) => ...,
    (request: Request) => ...
  )
)
```
npm package: @morphism/utils
Description: @morphism/utils
Latest version: 0.1.9

# @morphism/utils

A re-export of [fp-ts-contrib](https://github.com/gcanti/fp-ts-contrib) with some additional convenience functions/domains:
- `JSON`: an FP wrapper around the native `JSON.stringify` and `JSON.parse` methods
- `Do`: Haskell-inspired [do-notation](https://en.wikibooks.org/wiki/Haskell/do_notation) for `Either`, `TaskEither`, `Option`, and `Task`

<br/>

### Examples

#### `Do`

```typescript
const addTen = ({ a }:{ a: number }) => Either.right(a + 10)

const doNotation = Do.forEither()        // Initiates do notation context for `Either`
  .let('a', 10)                          // Set 'a' to 10 in the context
  .bindL('b', addTen)                    // Lazily passes in 'a' to 'addTen' & binds result to context under 'b'
  .return(({ a }) => `${a} dollars`)     // Returns a value derived from the context

const result = pipe(
  doNotation,
  Either.getOrElse(() => `0 dollars`)
)

expect(result).toEqual('20 dollars')
```

<br/>

#### `JSON`

Converting to JSON:
```typescript
import { Either } from "@morphism/fp";
import { JSON } from "@morphism/utils";

const short = pipe(
  { someField: "someValue" },
  JSON.Stringify.short,
  Either.fold(
    () => "{}",
    (json) => json 
  )
)

expect(short).toEqual('{ "someField": "someValue" }')
```

Converting to pretty JSON:
```typescript

const pretty = pipe(
  { someField: "someValue" },
  JSON.Stringify.pretty,
  Either.fold(
    () => "{}",
    (json) => json
  )
)

expect(pretty).toEqual('{\n  "someField": "someValue"\n}')

```

Converting to pretty JSON and never failing:
```typescript
const result = JSON.Stringify.Always.pretty({ someField: "someValue" })

expect(result).toEqual('{\n  "someField": "someValue"\n}')
```
npm package: @morphixai/icons
Description: MorphixAI custom icons - complements lucide-react with AI & product-specific icons
Author: MorphixAI
Latest version: 0.1.0

# @morphixai/icons

MorphixAI custom icon library. Complements [lucide-react](https://lucide.dev) with AI-specific and product-specific icons.

## Install

```bash
npm install @morphixai/icons
```

## Usage

```tsx
// General icons → use lucide-react directly
import { Search, Plus, Settings } from 'lucide-react';

// MorphixAI custom icons → this package
import { IconSparkle, IconWorkspace, IconDeepResearch } from '@morphixai/icons';

// Default outline style
<IconSparkle size={20} />

// Filled variant
<IconSparkle variant="fill" size={20} />

// Custom color via className
<IconSparkle className="text-blue-500" size={16} />
```

## Icons

### AI & Smart
- `IconSparkle` - AI feature entry (outline + fill)
- `IconLightning` - Quick action (outline + fill)
- `IconBrain` - AI thinking (outline)
- `IconDeepResearch` - Deep research mode (outline + fill)
- `IconMagicWand` - AI generation (outline)

### Product
- `IconWorkspace` - Workspace dashboard (outline + fill)
- `IconMemory` - Memory system (outline)
- `IconMiniApp` - Mini application (outline)

### Editor Extensions
- `IconMindMap` - Mind map (outline)
- `IconWhiteboard` - Whiteboard (outline)
- `IconTranslate` - Translation (outline)
- `IconFunction` - Formula / function (outline)

## Variants

All icons support the `variant` prop:

```tsx
<IconSparkle variant="outline" />  // Default - stroke style
<IconSparkle variant="fill" />     // Filled style
```

## Brand Assets

Logo files are available at `@morphixai/icons/brand/*`:

```tsx
import logo from '@morphixai/icons/brand/logo.png';
```

## Create Custom Icons

```tsx
import { createIcon } from '@morphixai/icons';

const IconCustom = createIcon('Custom', {
  outline: <path d="M..." />,
  fill: <path d="M..." fill="currentColor" />,
});
```

## Design Specs

- Style: Outline, 2px stroke, round cap/join
- ViewBox: 24x24
- Color: `currentColor` (inherits from parent)

## License

MIT
npm package: @morphl2/create-morph-app
Description: Create Morph applications with various templates
Author: Ernest Nnamdi
Latest version: 2.0.2

# Create Morph App

Create Morph applications with different templates and configurations.

## Quick Start

```bash
npx @morphl2/create-morph-app@latest
```

## Available Templates

### Basic Starter Kit

A clean foundation for building on Morph, including:

- Hardhat & Foundry development environment
- Next.js frontend with Web3 integration
- Wallet connection setup
- Basic smart contract examples

### Pyth Oracle Template

Everything in the basic kit plus:

- Pyth Oracle integration
- Price feed examples
- Oracle data display components

## Environment Setup

After creating your project, you'll need to set up your environment:

### Frontend (.env.local)

```
NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID=your_wallet_connect_project_id
```

### Smart Contracts (.env)

```
PRIVATE_KEY=your_private_key_here
RPC_URL=your_rpc_url_here
```

## Project Structure

Both templates follow the same basic structure:

```
your-app/
├── contracts/
│   ├── hardhat/
│   │   ├── contracts/
│   │   ├── scripts/
│   │   └── test/
│   └── foundry/
│       ├── src/
│       ├── test/
│       └── script/
└── frontend/
    ├── app/
    ├── components/
    └── public/
```

## Development

1. Set up environment variables
2. Install dependencies in each directory
3. Start frontend development server
4. Deploy contracts using Hardhat or Foundry

## License

MIT
npm package: @morphl2/create-pyth-app
Description: Create a new Morph application with Pyth Oracle integration
Author: Ernest Nnamdi
Latest version: 1.0.1

# Create Morph Pyth Kit

This package allows you to quickly set up a new Morph application with Pyth Oracle integration.

## Usage

Run the following command to create a new Morph Pyth app:

```
npx @morphl2/create-pyth-app@latest
```

Follow the prompts to set up your new project.

## What's Included

- Hardhat setup for smart contract development
- Foundry setup for additional testing options
- Next.js frontend with Web3 integration
- Pyth Oracle integration for price feed data
- Basic smart contract and frontend examples

## Getting Started

After creating your project, follow these steps:

1. Navigate into the project directory:

   ```
   cd your-project-name
   ```

2. Set up the frontend:

   ```
   cd frontend
   ```

3. Create a `.env.local` file in the frontend directory:

   ```
   touch .env.local
   ```

4. Open the `.env.local` file and add your WalletConnect Project ID:

   ```
   NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID=your_walletconnect_project_id_here
   ```

   Replace `your_walletconnect_project_id_here` with your actual WalletConnect Project ID. You can get this ID by signing up at [WalletConnect Cloud](https://cloud.walletconnect.com/).

5. Install frontend dependencies:

   ```
   yarn install
   ```

6. Return to the project root and set up Hardhat:

   ```
   cd ../contracts/hardhat
   yarn install
   ```

7. Set up Foundry:

   ```
   cd ../foundry
   forge install
   ```

8. Return to the project root:
   ```
   cd ../../
   ```

Refer to the README files in each directory for more information on how to use and develop your app.

## Important Note

Make sure to keep your `.env.local` file secure and never commit it to version control, as it contains sensitive information.

## License

This project is licensed under the MIT License.
npm package: @morphllm/gitmorph
Description: GitMorph CLI — work with gitmorph.com from the command line
Latest version: 0.2.6

# GitMorph CLI

Command-line tool for [gitmorph.com](https://gitmorph.com). Manage repos, issues, PRs, CI/CD, and more from your terminal.

## Install

```bash
npm i -g gitmorph
```

Or with curl:

```bash
curl -fsSL https://gitmorph.com/cli/install.sh | sh
```

Or with Homebrew:

```bash
brew install morphllm/tap/gm
```

## Usage

```bash
# Authenticate
gm auth login

# Repositories
gm repo list
gm repo create my-project
gm repo clone owner/repo

# Issues
gm issue list
gm issue create --title "Bug report"

# Pull requests
gm pr list
gm pr create --title "Feature" --base main

# CI/CD
gm workflow list
gm run list

# Search
gm search code "function"
gm search repos "keyword"
```

Run `gm --help` for the full command list.

## Requirements

macOS (arm64, x64) or Linux (arm64, x64). The npm package downloads a prebuilt binary during install.
npm package: @morphllm/morph-setup
Description: Install Morph MCP and bundled skills onto coding agents
Latest version: 1.0.8

# @morphllm/morph-setup

One-line installer for Morph MCP and bundled skills. Also includes a2a-review, which creates an AI "twin" that reviews PRs in your style.

## Install

```bash
npx -y @morphllm/morph-setup
```

The CLI will guide you through selecting which apps to install to.

### With API Key

```bash
npx -y @morphllm/morph-setup --morph-api-key <your-key>
```

Or set the environment variable:

```bash
MORPH_API_KEY=<your-key> npx -y @morphllm/morph-setup
```

### Non-interactive

```bash
npx -y @morphllm/morph-setup -y
```

## a2a-review: Agent Twin Code Review

Set up an AI twin that reviews PRs using your coding preferences, learned from your CLAUDE.md files.

### Quick start

```bash
npx -y @morphllm/morph-setup --morph-api-key <your-key> --a2a-review
```

The CLI will:
1. Verify your API key
2. Auto-detect your GitHub username (from `gh` CLI or git config)
3. Scan for CLAUDE.md files (global, project, and agent definitions)
4. Sanitize content (strips API keys, replaces absolute paths)
5. Upload to generate a review personality via Anthropic

### Non-interactive mode

All arguments can be passed explicitly to skip prompts:

```bash
npx -y @morphllm/morph-setup \
  --morph-api-key sk-... \
  --a2a-review \
  --github-username octocat \
  --claude-md ~/.claude/CLAUDE.md ./CLAUDE.md
```

### File scanning

When `--claude-md` is not provided, the CLI scans automatically:

- `~/.claude/CLAUDE.md` (global config, highest priority)
- `<cwd>/CLAUDE.md` and parent directories (walks up to root)
- `~/.claude/**/CLAUDE.md` (recursive, any nested CLAUDE.md)
- `~/.claude/**/agents/*.md` (agent definition files)

Skipped directories: plans, cache, skills, plugins, memory, worktrees, node_modules, .git

Combined content is truncated at ~100k tokens if it exceeds the limit.

### Options

| Flag | Description |
|------|-------------|
| `--a2a-review` | Enter a2a-review setup mode |
| `--github-username <name>` | GitHub username (skips auto-detection) |
| `--claude-md <paths...>` | Explicit CLAUDE.md file paths (skips auto-scan) |
| `--morph-api-key <key>` | Morph API key (or set `MORPH_API_KEY` env var) |

### What it generates

A ~500-word review personality profile covering:
- Code review priorities (correctness, performance, security, readability)
- Strictness level and what they consider nitpicky vs important
- Communication style (direct, explanatory, socratic)
- Language/framework expertise
- Red flags they focus on

This personality is injected into the system prompt when the twin reviews PRs, steering its focus areas and tone to match the developer.

### Invite your team

Each developer runs the CLI with their own API key:

```bash
npx -y @morphllm/morph-setup --morph-api-key <THEIR_KEY> --a2a-review
```

Manage twins at: https://morphllm.com/dashboard/integrations/github

## License

MIT
npm package: @morpho-dev/mempool
Description: A tiny helper around the Morpho Mempool API.
Latest version: 0.0.32

# Mempool Client

A tiny helper around the Morpho Mempool API.

## Install

```bash
npm i @morpho-dev/mempool
# or
pnpm add @morpho-dev/mempool
```

## Usage

### Add an offer to the mempool

```ts
import { Mempool, Offer } from "@morpho-dev/mempool";
import { http, createWalletClient } from "viem";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";

const client = createWalletClient({
  chain: mainnet,
  account: privateKeyToAccount(generatePrivateKey()),
  transport: http("<rpc url>"),
});

const mempool = Mempool.connect({ client, mempoolAddress: "<address of the mempool contract>" });

const now = Math.floor(Date.now() / 1000);

const offer = Offer.from({
    offering: wallet.account.offering,
    assets: 1000000n,
    rate: 1000000n,
    maturity: now + 60 * 60 * 24 * 30,
    expiry: now + 60 * 60 * 24 * 10,
    nonce: 2n,
    buy: true,
    chainId: 1n,
    loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    collaterals: [
      {
        asset: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
        oracle: "0x986b5E1e1755e3C2440e960477f25201B0a8bbD4",
        lltv: 860000000000000000n,
      },
    ],
    callback: {
      offering: zeroAddress,
      data: "0x",
      gasLimit: BigInt(0),
    },
  });

offer.signature = await Offer.sign(offer, client);

const signedOffer = await mempool.add({ offer });

console.log(signedOffer);
```

### Get offers from the mempool

```ts
import { Mempool } from "@morpho-dev/mempool";

const client = createWalletClient({
  chain: mainnet,
  account: privateKeyToAccount(generatePrivateKey()),
  transport: http("<rpc url>"),
});

const mempool = Mempool.connect({ client, mempoolAddress: "<address of the mempool contract>" });

const offers = await mempool.get();

console.log(offers);
```

### Watch for new offers

```ts
import { Mempool } from "@morpho-dev/mempool";

const client = createWalletClient({
  chain: mainnet,
  account: privateKeyToAccount(generatePrivateKey()),
  transport: http("<rpc url>"),
});

const mempool = Mempool.connect({ client, mempoolAddress: "<address of the mempool contract>" });

const unwatch = mempool.watch({
  polling: { interval: 30_000 }, // 30 seconds
  onOffers: async (offers) => {
    console.log(offers); // add custom logic in the callback
  },
});

unwatch(); // Stop watching for new offers
```
npm package: @morpho-dev/v2-deployment
Description: Morpho v2 chain configurations for viem
Author: Morpho Labs
Latest version: 0.3.1

# @morpho-dev/v2-deployment

Morpho v2 chain configurations and contract deployment tools for viem.

## Features

- 🔗 Pre-configured Morpho Ethereum fork chain for viem
- 📋 TypeScript ABI generation
- 📍 Address registry with deployment metadata
- 🔧 Blue SDK integration helpers

## Installation

```bash
npm install @morpho-dev/v2-deployment
# or
bun add @morpho-dev/v2-deployment
```

## Fork Definition

The **Morpho Ethereum Fork** is a development chain that replicates Ethereum mainnet state at a specific block, pre-configured with:

- **Chain ID**: `109111114`
- **Base**: Ethereum mainnet fork
- **Purpose**: Development, testing, and integration of Morpho v2 protocols
- **Features**:
  - All mainnet contracts and state available
  - Pre-deployed Morpho v2 contracts
  - Blue SDK integration with mainnet token data
  - Fast block times for development

### Shared Development Addresses

For internal testing and development, use these pre-funded Anvil addresses:

| Label | Address | Private Key |
|-------|---------|-------------|
| **Alice** | `0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266` | `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80` |
| **Bob** | `0x70997970C51812dc3A010C7d01b50e0d17dc79C8` | `0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d` |
| **Charlie** | `0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC` | `0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a` |
| **Dave** | `0x90F79bf6EB2c4f870365E785982E1f101E93b906` | `0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6` |
| **Eve** | `0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65` | `0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a` |

> ⚠️ **Warning**: These are well-known test keys. Never use them on mainnet or with real funds.

## Blue SDK Integration

```typescript
import { setupMorphoFork, morphoEthereumFork, deployments, termsAbi } from '@morpho-dev/v2-deployment';
import { getChainAddresses } from '@morpho-org/blue-sdk';
import { createPublicClient, getContract } from "viem";

// Setup Morpho fork with mainnet data (addresses, deployments, tokens) in the blue sdk
// Required only if you want to use the blue-sdk
setupMorphoFork();

// Get typed addresses for the fork
const addresses = getChainAddresses(morphoEthereumFork.id)
console.log('Morpho address:', addresses.morpho);


const client = createPublicClient({
  chain: morphoEthereumFork,
  transport: http() // will use the default rpc url
});

const termsContract = getContract({
  client,
  address: deployments[morphoEthereumFork.id].terms.address,
  abi: termsAbi,
})

```
npm package: @morpho-labs/ethers-fallback-provider
Description: Package providing a fallback provider based on ethers-providers, adding more resilience.
Latest version: 1.1.0

# ethers-fallback-provider
[![npm package][npm-img]][npm-url]
[![Build Status][build-img]][build-url]
[![Downloads][downloads-img]][downloads-url]
[![Issues][issues-img]][issues-url]
[![Commitizen Friendly][commitizen-img]][commitizen-url]
[![Semantic Release][semantic-release-img]][semantic-release-url]

> Package providing a fallback provider based on `ethers` package, adding more resilience.

The provider fallbacks on multiple providers in case of failure, and returns the first successful result.

It throws an error if all providers failed.

The providers are called in the order they are passed to the constructor.

Contrary to the `FallbackProvider` provided by `ethers`, this one does not use all providers at the same time, but only one at a time.
The purpose is more to have resilience if one provider fails, rather than having a resilience on the result.

## Installation
```bash
npm install @morpho-labs/ethers-fallback-provider
```
or
```bash
yarn add @morpho-labs/ethers-fallback-provider
```

## Usage

```typescript
import FallbackProvider from '@morpho-labs/ethers-fallback-provider';

import { 
    InfuraProvider, 
    AlchemyProvider, 
    getDefaultProvider 
} from "@ethersproject/providers";


const timeout = 1000; // 1 second, optionnal, default is 3000ms

const provider = new FallbackProvider([
    {
        provider: new InfuraProvider('mainnet', 'your-api-key'),
        retries: 3, // retry after a timeout or an error 3 times, default is 0.
        timeout,
        retryDelay: 1000 // wait a random time less than 1 second before retrying. Default is 0.
    },
    new AlchemyProvider('mainnet', 'your-api-key'),
    getDefaultProvider('mainnet')
]);

// You can now use the fallback provider as a classic provider
const blockNumber = await provider.getBlockNumber();

```


[build-img]: https://github.com/morpho-labs/ethers-fallback-provider/actions/workflows/ci.yaml/badge.svg?branch=main
[build-url]: https://github.com/morpho-labs/ethers-fallback-provider/actions/workflows/ci.yaml
[downloads-img]: https://img.shields.io/npm/dt/ethers-multicall-provider
[downloads-url]: https://www.npmtrends.com/ethers-multicall-provider
[npm-img]: https://img.shields.io/npm/v/ethers-multicall-provider
[npm-url]: https://www.npmjs.com/package/ethers-multicall-provider
[issues-img]: https://img.shields.io/github/issues/morpho-labs/ethers-fallback-provider
[issues-url]: https://github.com/morpho-labs/ethers-fallback-provider/issues
[codecov-img]: https://codecov.io/gh/morpho-labs/ethers-fallback-provider/branch/main/graph/badge.svg
[codecov-url]: https://codecov.io/gh/morpho-labs/ethers-fallback-provider
[semantic-release-img]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
[semantic-release-url]: https://github.com/semantic-release/semantic-release
[commitizen-img]: https://img.shields.io/badge/commitizen-friendly-brightgreen.svg
[commitizen-url]: http://commitizen.github.io/cz-cli/
npm package: @morpho-labs/ethers-utils
Description: ⚡🚀 Use ethers-js easily
Author: Julien
Latest version: 1.2.0

# ethers-utils

[![npm package][npm-img]][npm-url]
[![Build Status][build-img]][build-url]
[![Downloads][downloads-img]][downloads-url]
[![Issues][issues-img]][issues-url]
[![Commitizen Friendly][commitizen-img]][commitizen-url]
[![Semantic Release][semantic-release-img]][semantic-release-url]

> ⚡🚀 Use built in scripts on stop of ethers-js

## Install

```bash
npm install ethers @morpho-labs/ethers-utils
```

```bash
yarn add ethers @morpho-labs/ethers-utils
```

[build-img]: https://github.com/morpho-labs/ethers-utils/actions/workflows/release.yml/badge.svg
[build-url]: https://github.com/morpho-labs/ethers-utils/actions/workflows/release.yml
[downloads-img]: https://img.shields.io/npm/dt/@morpho-labs/ethers-utils
[downloads-url]: https://www.npmtrends.com/@morpho-labs/ethers-utils
[npm-img]: https://img.shields.io/npm/v/@morpho-labs/ethers-utils
[npm-url]: https://www.npmjs.com/package/@morpho-labs/ethers-utils
[issues-img]: https://img.shields.io/github/issues/morpho-labs/ethers-utils
[issues-url]: https://github.com/morpho-labs/ethers-utils/issues
[codecov-img]: https://codecov.io/gh/morpho-labs/ethers-utils/branch/main/graph/badge.svg
[codecov-url]: https://codecov.io/gh/morpho-labs/ethers-utils
[semantic-release-img]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
[semantic-release-url]: https://github.com/semantic-release/semantic-release
[commitizen-img]: https://img.shields.io/badge/commitizen-friendly-brightgreen.svg
[commitizen-url]: http://commitizen.github.io/cz-cli/