open-index/open-npm huggingface dataset:
npm package: @kaiord/fit
Description: FIT format adapter for the Kaiord health & fitness data framework
Author: Kaiord Contributors
Latest version: 4.8.1

# @kaiord/fit

[![npm version](https://img.shields.io/npm/v/@kaiord/fit.svg)](https://www.npmjs.com/package/@kaiord/fit)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

FIT format adapter for the Kaiord health & fitness data framework. Provides reading and writing of Garmin FIT workout files using the official Garmin FIT SDK.

## Installation

```bash
pnpm add @kaiord/core @kaiord/fit
```

## Usage

### With Core Providers (Recommended)

```typescript
import { createDefaultProviders } from "@kaiord/core";
import { createFitProviders } from "@kaiord/fit";

const providers = createDefaultProviders({
  fit: createFitProviders(),
});

// FIT to KRD
const krd = await providers.convertFitToKrd!({ fitBuffer });

// KRD to FIT
const fitBuffer = await providers.convertKrdToFit!({ krd });
```

### Standalone Adapter Access

```typescript
import {
  createGarminFitSdkReader,
  createGarminFitSdkWriter,
} from "@kaiord/fit";
import { createConsoleLogger } from "@kaiord/core";

const logger = createConsoleLogger();
const reader = createGarminFitSdkReader(logger);
const writer = createGarminFitSdkWriter(logger);
```

## API

### `createFitProviders(logger?: Logger): FitProviders`

Creates FIT adapter instances for use with `createDefaultProviders()`.

### `createGarminFitSdkReader(logger: Logger): FitReader`

Creates a FIT file reader using the Garmin FIT SDK.

### `createGarminFitSdkWriter(logger: Logger): FitWriter`

Creates a FIT file writer using the Garmin FIT SDK.

## Supported FIT Features

- Workout files (structured workout steps)
- Activity files (recorded activity data)
- Course files (GPS routes)
- Lap messages
- Record messages (time-series data)
- Event messages
- Session/activity metadata

## License

MIT
npm package: @kaiord/garmin
Description: Garmin Connect API (GCN) format adapter for the Kaiord health & fitness data framework
Author: Kaiord Contributors
Latest version: 5.0.0

# @kaiord/garmin

[![npm version](https://img.shields.io/npm/v/@kaiord/garmin.svg)](https://www.npmjs.com/package/@kaiord/garmin)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Garmin Connect API format adapter for the Kaiord health & fitness data framework. Provides bidirectional conversion between Garmin Connect workout JSON format and KRD.

## Installation

```bash
pnpm add @kaiord/core @kaiord/garmin
```

## Usage

### With Core Providers (Recommended)

```typescript
import { createDefaultProviders } from "@kaiord/core";
import { createGarminProviders } from "@kaiord/garmin";

const providers = createDefaultProviders({
  garmin: createGarminProviders(),
});

// Garmin to KRD
const krd = await providers.convertGarminToKrd!({ garminString });

// KRD to Garmin
const garminString = await providers.convertKrdToGarmin!({ krd });
```

### Standalone Adapter Access

```typescript
import {
  createGarminConnectReader,
  createGarminConnectWriter,
} from "@kaiord/garmin";
import { createConsoleLogger } from "@kaiord/core";

const logger = createConsoleLogger();
const reader = createGarminConnectReader(logger);
const writer = createGarminConnectWriter(logger);
```

## API

### `createGarminProviders(logger?: Logger): GarminProviders`

Creates Garmin adapter instances for use with `createDefaultProviders()`.

### `createGarminConnectReader(logger: Logger): GarminReader`

Creates a Garmin Connect JSON reader.

### `createGarminConnectWriter(logger: Logger): GarminWriter`

Creates a Garmin Connect JSON writer.

## Supported Garmin Features

- Workout definitions with structured steps
- Power, heart rate, speed, and cadence targets
- Time-based, distance-based, and calorie-based durations
- Repeat blocks (intervals)
- Multiple sport types
- Custom step names and notes

## License

MIT
npm package: @kaiord/mcp
Description: MCP server for Kaiord fitness data conversion (FIT, TCX, ZWO, GCN, KRD)
Author: Kaiord Contributors
Latest version: 6.0.0

# @kaiord/mcp

Model Context Protocol (MCP) server for Kaiord. Exposes fitness file conversion, validation, and inspection tools to AI agents (Claude Desktop, Claude Code, etc.).

## Installation

```bash
npm install -g @kaiord/mcp
```

## Configuration

### Claude Desktop / Claude Code

Add to your MCP configuration:

```json
{
  "kaiord": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@kaiord/mcp"]
  }
}
```

### Local development (monorepo)

```json
{
  "kaiord": {
    "type": "stdio",
    "command": "node",
    "args": ["./packages/mcp/dist/bin/kaiord-mcp.js"]
  }
}
```

## Tools

| Tool                     | Description                                         |
| ------------------------ | --------------------------------------------------- |
| `kaiord_convert`         | Convert between FIT, TCX, ZWO, GCN, and KRD formats |
| `kaiord_validate`        | Validate KRD JSON against the schema                |
| `kaiord_inspect`         | Parse and summarize any fitness file                |
| `kaiord_diff`            | Compare two fitness files                           |
| `kaiord_extract_workout` | Extract structured workout definition               |
| `kaiord_list_formats`    | List supported formats and capabilities             |

## Resources

| URI                        | Description                         |
| -------------------------- | ----------------------------------- |
| `kaiord://schema/krd`      | KRD JSON Schema                     |
| `kaiord://formats`         | Supported formats with capabilities |
| `kaiord://docs/krd-format` | KRD format specification            |

## Prompts

| Name              | Description                             |
| ----------------- | --------------------------------------- |
| `convert_file`    | Guided file conversion workflow         |
| `analyze_workout` | Inspect + extract + summarize a workout |

## Supported Formats

| Format | Extension | Type   | Description                  |
| ------ | --------- | ------ | ---------------------------- |
| FIT    | `.fit`    | Binary | Garmin FIT protocol          |
| TCX    | `.tcx`    | Text   | Training Center XML          |
| ZWO    | `.zwo`    | Text   | Zwift workout XML            |
| GCN    | `.gcn`    | Text   | Garmin Connect workout JSON  |
| KRD    | `.krd`    | Text   | Kaiord canonical JSON format |

## License

MIT
npm package: @kaiord/tcx
Description: TCX format adapter for the Kaiord health & fitness data framework
Author: Kaiord Contributors
Latest version: 4.8.1

# @kaiord/tcx

[![npm version](https://img.shields.io/npm/v/@kaiord/tcx.svg)](https://www.npmjs.com/package/@kaiord/tcx)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

TCX format adapter for the Kaiord health & fitness data framework. Provides reading, writing, and XSD validation of Garmin Training Center XML files.

## Installation

```bash
pnpm add @kaiord/core @kaiord/tcx
```

## Usage

### With Core Providers (Recommended)

```typescript
import { createDefaultProviders } from "@kaiord/core";
import { createTcxProviders } from "@kaiord/tcx";

const providers = createDefaultProviders({
  tcx: createTcxProviders(),
});

// TCX to KRD
const krd = await providers.convertTcxToKrd!({ tcxString });

// KRD to TCX
const tcxString = await providers.convertKrdToTcx!({ krd });
```

### Standalone Adapter Access

```typescript
import {
  createFastXmlTcxReader,
  createFastXmlTcxWriter,
  createXsdTcxValidator,
} from "@kaiord/tcx";
import { createConsoleLogger } from "@kaiord/core";

const logger = createConsoleLogger();
const reader = createFastXmlTcxReader(logger);
const writer = createFastXmlTcxWriter(logger, createXsdTcxValidator(logger));
const validator = createXsdTcxValidator(logger);
```

## API

### `createTcxProviders(logger?: Logger): TcxProviders`

Creates TCX adapter instances for use with `createDefaultProviders()`.

### `createFastXmlTcxReader(logger: Logger): TcxReader`

Creates a TCX file reader using fast-xml-parser.

### `createFastXmlTcxWriter(logger: Logger, validator: TcxValidator): TcxWriter`

Creates a TCX file writer using fast-xml-parser.

### `createXsdTcxValidator(logger: Logger): TcxValidator`

Creates an XSD schema validator for TCX files.

## Supported TCX Features

- Workout definitions with structured steps
- Heart rate, speed, and cadence targets
- Time-based and distance-based durations
- Repeat blocks (intervals)
- Multiple sport types

## License

MIT
npm package: @kaiord/zwo
Description: ZWO format adapter for the Kaiord health & fitness data framework
Author: Kaiord Contributors
Latest version: 4.8.1

# @kaiord/zwo

[![npm version](https://img.shields.io/npm/v/@kaiord/zwo.svg)](https://www.npmjs.com/package/@kaiord/zwo)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

ZWO format adapter for the Kaiord health & fitness data framework. Provides reading, writing, and validation of Zwift workout XML files.

## Installation

```bash
pnpm add @kaiord/core @kaiord/zwo
```

## Usage

### With Core Providers (Recommended)

```typescript
import { createDefaultProviders } from "@kaiord/core";
import { createZwoProviders } from "@kaiord/zwo";

const providers = createDefaultProviders({
  zwo: createZwoProviders(),
});

// ZWO to KRD
const krd = await providers.convertZwiftToKrd!({ zwiftString });

// KRD to ZWO
const zwoString = await providers.convertKrdToZwift!({ krd });
```

### Standalone Adapter Access

```typescript
import {
  createFastXmlZwiftReader,
  createFastXmlZwiftWriter,
  createZwiftValidator,
} from "@kaiord/zwo";
import { createConsoleLogger } from "@kaiord/core";

const logger = createConsoleLogger();
const validator = createZwiftValidator(logger);
const reader = createFastXmlZwiftReader(logger, validator);
const writer = createFastXmlZwiftWriter(logger, validator);
```

## API

### `createZwoProviders(logger?: Logger): ZwoProviders`

Creates ZWO adapter instances for use with `createDefaultProviders()`.

### `createFastXmlZwiftReader(logger: Logger, validator: ZwiftValidator): ZwiftReader`

Creates a ZWO file reader using fast-xml-parser.

### `createFastXmlZwiftWriter(logger: Logger, validator: ZwiftValidator): ZwiftWriter`

Creates a ZWO file writer using fast-xml-parser.

### `createZwiftValidator(logger: Logger): ZwiftValidator`

Creates a validator that uses XSD validation in Node.js and well-formedness checking in browsers.

### `createXsdZwiftValidator(logger: Logger): ZwiftValidator`

Creates a strict XSD schema validator (Node.js only).

## Supported ZWO Features

- SteadyState intervals
- Warmup and Cooldown ramps
- IntervalsT (structured intervals)
- FreeRide segments
- Power targets (FTP percentage)
- Heart rate and cadence targets
- Text events

## License

MIT
npm package: @kaiouwang/react-c3js
Description: React component for C3.js
Author: Kaiou Wang
Latest version: 0.1.20

# react-c3js

[![NPM version][npm-image]][npm-url]

React component for [C3.js](http://c3js.org/). ([Demo])

This folk fixed an issue where chart unloading didn't finish properly before new data starts rendering.

> If you call load API soon after/before unload, unload param of load should be used. Otherwise chart will not be rendered properly because of cancel of animation. [link](https://c3js.org/reference.html#api-unload)

![screenshot](screenshot.png)

```javascript
import C3Chart from 'react-c3js';
import 'c3/c3.css';

const data = {
  columns: [
    ['data1', 30, 200, 100, 400, 150, 250],
    ['data2', 50, 20, 10, 40, 15, 25]
  ]
};

const mountNode = document.getElementById('react-c3js');

ReactDOM.render(<C3Chart data={data} />, mountNode);
```

You can see the `docs` for more details.

[Demo]: http://bcbcarl.github.io/react-c3js/

## Installation

```
$ npm install --save react-c3js
```

## Contributing

### Yarn / NPM

1. Modify `src/index.js`.
2. Build the lib by using `npm run build` or `make build`.
3. Import C3Chart from react-c3js.
4. See the result.

### Docker

```bash
docker build -t react-c3js .
docker run --rm -p 9966:9966 --name react-c3js react-c3js
docker stop react-c3js
```

## Properties

Check out [C3.js Reference](http://c3js.org/reference.html) for more details.

* data
* title
* size
* padding
* color
* interaction
* transition
* oninit
* onrendered
* onmouseover
* onmouseout
* onresize
* onresized
* axis
* grid
* regions
* legend
* tooltip
* subchart
* zoom
* point
* line
* area
* bar
* pie
* donut
* gauge
* className
* style
* unloadBeforeLoad
* onPropsChanged

## License

MIT

[npm-image]: https://img.shields.io/npm/v/react-c3js.svg?style=flat-square
[npm-url]: https://npmjs.org/package/react-c3js
npm package: @kaipio/api
Description: This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.1.2.
Latest version: 0.1.3

# @kaipio/api library

This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.1.2.

Components use [Bootstrap 4](https://getbootstrap.com/) for UI by default.

This library contains some Angular components, that will consume data operations from our [api.kaipio.com](https://api.kaipio.com) server.

# Components

# FinnArea component

This component allows user to select area information from Finland in UI.

## Examples

See example in our website [https://www.kaipio.com/aps/finnareaui/angular](https://www.kaipio.com/aps/finnareaui/angular). Created with ASP.NET C# MVC.

## Usage

Add import to your app.module.ts

```
import { ApiModule} from '@kaipio/api';
```

Add import in your app.module.ts imports

```
ApiModule.forRoot({ showFinnareaCity: true, showFinnareaCounty: true, showFinnareaRegion: true, showFinnareaSelectionInfo: true }),
```

You can use forRoot parameters to configure component parts visibility. If you set all to true, you will get all UI elements. You can also use any config combinations to get UI you need.

If you need to set component parts visibility at runtime, you can use property setter functions to do that.

```
setSelectionInfoVisible(false); // hide selection info 

setRegionSelection(); // set to show only region selection

setCountySelection(); // set to show only county selection

setCitySelection(); // set to show only city selection
```

You can receive selection info from component using events. Add this code to your app.components.ts to get city selection to console:

```
private cityEvent: CustomEvent;
  
ngOnInit() {
    fromEvent(document, 'CitySelected').subscribe(cityEv => {
      this.cityEvent = cityEv as CustomEvent;
      console.log(this.cityEvent.detail.City);      
    });
}

```

Other events are CountySelected and RegionSelected.

## License

When version 1.0.0 is published, the library will be commercial and will require license to be purchased.

Copyright © 2020 T:mi Jari Kaipio. All rights reserved.
npm package: @kaiquegl/megamenu
Description: leanworkgroup megamenu for rchlo &amp; carters
Latest version: 2.0.1

# lean-megamenu

> leanworkgroup megamenu for rchlo &amp; carters

[![NPM](https://img.shields.io/npm/v/lean-megamenu.svg)](https://www.npmjs.com/package/lean-megamenu) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install @kaiquegl/megamenu
```

```bash
yarn add @kaiquegl/megamenu
```

## Usage

```tsx
import React, { Component } from 'react'

import MegaMenu from '@kaiquegl/megamenu'

class Example extends Component {
  render() {
    return <MegaMenu />
  }
}
```

## License

MIT © [](https://github.com/)
npm package: @kairenxyz/dealrail
Description: CLI and SDK for DealRail procurement, negotiation, and escrow rails
Latest version: 0.1.1

# `@kairenxyz/dealrail`

Publishable CLI and SDK package for DealRail.

It supports two modes:

- Human mode: ASCII command deck output for terminal use
- Agent mode: stable JSON with `--json`

## Install

Preferred once published:

```bash
npx @kairenxyz/dealrail doctor --json
npx @kairenxyz/dealrail vend "benchmark report" --budget 0.12 --hours 24 --json
```

Global install:

```bash
npm install -g @kairenxyz/dealrail
dealrail help
```

Local project install:

```bash
npm install @kairenxyz/dealrail
```

If you want the client in code:

```ts
import { DealRailClient } from '@kairenxyz/dealrail';

const client = new DealRailClient('http://localhost:3001');
const health = await client.health();
```

## Commands

```bash
dealrail help
dealrail demo
dealrail doctor
dealrail doctor --json
dealrail status
dealrail scan benchmark report
dealrail providers compliance checks --max-price 0.12
dealrail vend "benchmark report" --budget 0.12 --hours 24
dealrail vend "security review" --budget 0.20 --hours 48 --queue
dealrail rails
dealrail jobs --limit 8
dealrail job 12
```

## Configuration

Set the API base URL with either:

```bash
export DEALRAIL_API_URL=http://localhost:3001
```

or:

```bash
dealrail status --api http://localhost:3001
```

Recommended operator flow:

```bash
dealrail doctor
dealrail vend "automation benchmark report" --budget 0.12 --hours 24
dealrail jobs --limit 4
```

Recommended agent flow:

```bash
dealrail doctor --json
dealrail vend "automation benchmark report" --budget 0.12 --hours 24 --json
```

## Development

```bash
npm install
npm run check
npm run build
npm run pack:dry-run
npm run cli -- help
npm run demo
npm run demo:walkthrough
npm run start -- help
```

## Publish

Before first publish:

1. Run `npm login`
2. Run `npm run check`
3. Run `npm run pack:dry-run`
4. Run `npm publish --access public`

npm docs:

- https://docs.npmjs.com/about-scopes
- https://docs.npmjs.com/creating-and-publishing-scoped-public-packages

## Demo Walkthrough

A separate recordable CLI demo runner lives at `demo/dealrail-demo.sh`.

It animates typed commands, pauses between scenes, and runs a clean walkthrough for:

- `help`
- `status`
- `scan`
- `vend`
- `jobs`
- `rails`

Run it with:

```bash
cd cli
npm run build
npm run demo:walkthrough
```

Useful knobs for recording:

```bash
TYPE_SPEED=0.01 PAUSE_SHORT=0.8 PAUSE_LONG=1.6 npm run demo:walkthrough
DEALRAIL_API_URL=http://localhost:3001 npm run demo:walkthrough
```
npm package: @kairo-sh/ng-ui
Description: A reusable UI component library built with Angular and TailwindCSS, designed for all kairo.sh applications.
Author: Kairo.sh Team
Latest version: 0.1.2

# KairoUi

This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 19.2.0.

## Code scaffolding

Angular CLI includes powerful code scaffolding tools. To generate a new component, run:

```bash
ng generate component component-name
```

For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:

```bash
ng generate --help
```

## Building

To build the library, run:

```bash
ng build ng-ui
```

This command will compile your project, and the build artifacts will be placed in the `dist/` directory.

### Publishing the Library

Once the project is built, you can publish your library by following these steps:

1. Navigate to the `dist` directory:

   ```bash
   cd dist/ng-ui
   ```

2. Run the `npm publish` command to publish your library to the npm registry:
   ```bash
   npm publish
   ```

## Running unit tests

To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:

```bash
ng test
```

## Running end-to-end tests

For end-to-end (e2e) testing, run:

```bash
ng e2e
```

Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.

## Additional Resources

For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.
npm package: @kairoguard/sdk
Description: Kairo SDK for multi-chain policy-based transaction signing with dWallet support (EVM, Bitcoin, Solana, Sui)
Author: Kairo
Latest version: 0.0.16

# `@kairoguard/sdk`

Kairo SDK for multi-chain policy-based transaction signing with dWallet support.

## Features

- **Multi-chain intent computation**: EVM, Bitcoin, Solana
- **Policy-based gating**: Mint and validate PolicyReceipts on Sui
- **dWallet management**: Create and manage dWallets with policy bindings
- **Governance**: Propose, approve, and execute policy updates
- **Audit**: Verify custody events and audit bundles
- **CLI**: Command-line tools for key management and auditing

## Install

```bash
npm install @kairoguard/sdk
```

## Quick Start

### Initialize the client

```ts
import { KairoClient } from "@kairoguard/sdk";

const client = new KairoClient({
  backendUrl: "https://kairo-policy-engine-mmux6.ondigitalocean.app",
  apiKey: "your-api-key",
});
```

### Create a dWallet

```ts
const wallet = await client.createWallet({
  chain: "evm",
  policyStableId: "my-policy",
});
```

### Compute transaction intent (EVM example)

```ts
import { computeEvmIntentFromUnsignedTxBytes } from "@kairoguard/sdk";

const { intentHash } = computeEvmIntentFromUnsignedTxBytes({
  chainId: 84532, // Base Sepolia
  unsignedTxBytesHex: "0x...",
});
```

### Compute transaction intent (Solana example)

```ts
import { computeSolanaIntentHash } from "@kairoguard/sdk";

const intentHash = computeSolanaIntentHash({
  from: senderAddress,
  instructions: parsedInstructions,
});
```

### Build Sui receipt transaction

```ts
import { buildMintEvmReceiptTx } from "@kairoguard/sdk";

const tx = buildMintEvmReceiptTx({
  packageId: "0x...",
  policyObjectId: "0x...",
  evmChainId: 84532,
  intentHash,
  toEvm: recipientAddress,
});
```

### Policy governance

```ts
// Propose a policy update
const proposal = await client.proposePolicyUpdate({
  governanceId: "0x...",
  newPolicyObjectId: "0x...",
  description: "Update spend limits",
});

// Approve the proposal
await client.approvePolicyUpdate({
  governanceId: "0x...",
  proposalId: proposal.proposalId,
});

// Execute after threshold reached
await client.executePolicyUpdate({
  governanceId: "0x...",
  proposalId: proposal.proposalId,
});
```

## CLI Usage

```bash
# Audit a bundle
npx @kairoguard/sdk kairo-audit audit <bundle-path>

# List keys
npx @kairoguard/sdk kairo list-keys
```

## Documentation

For detailed documentation and examples, visit [www.kairoguard.com/docs](https://www.kairoguard.com/docs).
npm package: @kairolin/euno-ui
Description: A Vue component library inspired by the persistence of a snail
Author: Mollu UI Team
Latest version: 1.0.0

<p align="center">
  <img src="./public/logo.svg" alt="Euno UI Logo" width="200" />
  <img src="./public/logo2.svg" alt="Euno UI Logo" width="200" />
</p>

<h1 align="center">Euno UI</h1>

<p align="center">
  <strong>像蜗牛一样稳健前行的 Vue 3 组件库</strong>
</p>

<p align="center">
  <a href="https://github.com/mollu-ui/mollu-ui/blob/main/LICENSE">
    <img src="https://img.shields.io/npm/l/@mollu/ui.svg" alt="License">
  </a>
  <a href="https://www.npmjs.com/package/@mollu/ui">
    <img src="https://img.shields.io/npm/v/@mollu/ui/latest.svg" alt="NPM Version">
  </a>
  <!-- <a href="https://github.com/mollu-ui/mollu-ui/actions/workflows/publish.yml">
    <img src="https://github.com/mollu-ui/mollu-ui/actions/workflows/publish.yml/badge.svg" alt="Build Status">
  </a> -->
</p>

---

## 简介

Euno UI 是一个基于 Vue 3 和 TypeScript 的现代化组件库，其设计灵感来源于蜗牛的坚韧和稳健。我们相信，如同蜗牛一样，优秀的组件库应该以稳定可靠为核心，逐步前行，为开发者提供坚实的支持。

> 🐌 **奋进的蜗牛**：蜗牛虽然行动缓慢，但每一步都踏实稳健。Euno UI 亦如此，我们不追求一时的新奇，而更注重长期的稳定和可靠性。

## 特性

- 🐌 **稳健可靠**：如同蜗牛般稳定，每个组件都经过精心设计和测试
- ⚡ **基于 Vue 3**：充分利用 Vue 3 的新特性和性能优势
- 🔧 **TypeScript 支持**：提供完整的类型定义，提升开发体验
- 🎨 **UnoCSS 驱动**：轻量级样式解决方案，高度可定制
- 📱 **响应式设计**：支持各种设备尺寸，提供一致的用户体验
- 📦 **按需引入**：支持按需引入组件，减少打包体积

## 安装

```bash
# 使用 npm
npm install @euno/ui

# 使用 yarn
yarn add @euno/ui

# 使用 pnpm
pnpm add @euno/ui
```

## 快速开始

### 完整引入

```ts
import { createApp } from 'vue'
import App from './App.vue'
import EunoUI from '@euno/ui'
import '@euno/ui/dist/style.css' // 引入样式

const app = createApp(App)

app.use(EunoUI)
app.mount('#app')
```

### 按需引入

```ts
import { createApp } from 'vue'
import App from './App.vue'
import { EButton, ECard } from '@euno/ui'
import '@euno/ui/dist/style.css' // 引入样式

const app = createApp(App)

app.component('EButton', EButton)
app.component('ECard', ECard)
app.mount('#app')
```

## 文档

- [官方文档](./docs/)
- [组件列表](./docs/components/button.md)
- [API 规范](./docs/guide/api-spec.md)

## 示例

```vue
<template>
  <div class="container">
    <m-button type="primary" @click="handleClick">点击我</m-button>
    <m-card header="卡片标题">
      <p>这是卡片内容</p>
    </m-card>
  </div>
</template>

<script setup>
import { EButton, ECard } from '@euno/ui'

const handleClick = () => {
  console.log('按钮被点击了！')
}
</script>
```

## 设计理念

Euno UI 的设计灵感来源于"奋进的蜗牛"。蜗牛虽然行动缓慢，但每一步都踏实稳健，背负着自己的壳，稳步向前。这种精神体现在我们组件库的每一个细节中：

- **稳定性优先**：每个组件都经过充分测试，确保在各种场景下的稳定性
- **渐进式发展**：我们逐步完善组件库，不盲目追求数量
- **简洁易用**：API 设计简洁明了，易于理解和使用
- **性能卓越**：每个组件都经过性能优化，确保应用的流畅性

## 贡献

我们欢迎任何形式的贡献！

1. Fork 项目
2. 创建功能分支 (`git checkout -b feature/AmazingFeature`)
3. 提交你的修改 (`git commit -m 'Add some AmazingFeature'`)
4. 推送到分支 (`git push origin feature/AmazingFeature`)
5. 开启 Pull Request

## 开源协议

Euno UI 遵循 [MIT License](./LICENSE)。

## 致谢

感谢所有为 Euno UI 做出贡献的人们，以及 Vue.js 生态系统的优秀项目。
npm package: @kairos-computer/redis
Description: Redis adapter for [kai](https://github.com/kairos-computer/kai) — provides ready-made implementations of kai's Streaming, MessageQueue, and StopSignal services using [ioredis](https://github.com/redis/ioredis).
Latest version: 0.1.3

# @kairos-computer/redis

Redis adapter for [kai](https://github.com/kairos-computer/kai) — provides ready-made implementations of kai's Streaming, MessageQueue, and StopSignal services using [ioredis](https://github.com/redis/ioredis).

## Install

```bash
bun add @kairos-computer/redis
```

## Usage

```typescript
import { RedisStreamingLayer, RedisMessageQueueLayer, RedisStopSignalLayer } from "@kairos-computer/redis"
import Redis from "ioredis"

const redis = new Redis()
const subscriber = new Redis()

const streamingLayer = RedisStreamingLayer({ redis, userId: "user-123" })
const mqLayer = RedisMessageQueueLayer({
  redis,
  conversationId: "conv-1",
  consumerId: "agent-1",
  parseMessage: (data) => JSON.parse(data.payload),
})
const stopLayer = RedisStopSignalLayer({ redis, subscriber, conversationId: "conv-1" })
```

### Streaming

Publishes `StreamChunk` as JSON to a Redis Pub/Sub channel (`{prefix}:{userId}:chunks`).

### MessageQueue

Uses Redis Streams (`XREADGROUP`/`XACK`) for durable message queuing. `drain()` is non-blocking, `wait()` blocks until a message arrives, and `ack()` confirms messages after successful processing.

```typescript
import { ensureConsumerGroup } from "@kairos-computer/redis"

// Create consumer group (idempotent)
await ensureConsumerGroup(redis, "conv-1")
```

### StopSignal

Dual mechanism for reliable stop detection:
1. Persistent key (`GETDEL`) — survives pub/sub misses between turns
2. Pub/Sub channel — instant notification during streaming

```typescript
import { publishStopSignal } from "@kairos-computer/redis"

// Signal a conversation to stop
await publishStopSignal(redis, "conv-1")
```

See the [kai documentation](https://github.com/kairos-computer/kai) for full details.