open-index/open-npm huggingface dataset:
npm package: @savingsunited/vue3-tags-input
Description: A tags input component for Vue 3 with autocompletion, custom validation, templating and much more
Author: Johannes Munari
Latest version: 3.0.14

# vue-tags-input

A tags input component for Vue 3 with autocompletion, custom validation, templating and much more

Forked from [@johmun/vue-tags-input](https://www.npmjs.com/package/@johmun/vue-tags-input), which you should use instead if your project is on Vue 2. 

[Demo & Docs](http://www.vue-tags-input.com) (for the original version)

## Features

* No dependencies
* Custom validation rules
* Hooks: Before adding, Before deleting ...
* Edit tags after creation
* Fast setup
* Works with Vuex
* Small size: 34kb minified (css included) | gzipped 9kb
* Autocompletion
* Many customization options
* Own templates
* Delete tags on backspace
* Add tags on paste
* Examples & Docs
* Drag and Drop

## Install

NPM
```
npm install @sipec/vue3-tags-input
```

CDN
```
<script src="https://unpkg.com/@sipec/vue3-tags-input/dist/vue-tags-input.js"></script>
```

## Usage

```html
<template>
  <div>
    <vue-tags-input
      v-model="tag"
      :tags="tags"
      @tags-changed="newTags => tags = newTags"
    />
  </div>
</template>
```

```javascript
<script>
import VueTagsInput from "@sipec/vue3-tags-input";

export default {
  components: {
    VueTagsInput,
  },
  data() {
    return {
      tag: '',
      tags: [],
    };
  },
};
</script>
```

## Usage with draggable
Draggable is disabled by default. Set prop `:is-draggable` to true to enable it. You can also set `:draggable-handle` to true to enable handle which can be styled with css class `.handle`. Classes for ghost-class and drag-class are `.ghost-tag` and `.drag-tag`.

On drop `tag-order-changed` is emitted with array of tags in new order. Use this array to update your tags to save the new order.

```html
<template>
  <div>
    <vue-tags-input
      v-model="tag"
      :tags="tags"
      :is-draggable="true"
      @tags-changed="newTags => tags = newTags"
      @tag-order-changed="newTags => tags = newTags"
    />
  </div>
</template>
```

## Migration From Vue 2

This version is faithful to the original spec. The only thing you'll have to change is replacing any usages of `tags.sync` with `vmodel:tags` in the props

## License

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

Copyright (c) 2019 Johannes Munari
npm package: @savio629/schematics
Description: schematics for stencil applcations
Latest version: 0.0.5

# Custom Schematics

Custom schematics can streamline the process of generating code and adding features to your Nest.js project. Follow these steps to use your custom schematics:

1. **Initialize Your Nest Project**: Make sure you have a Nest.js project set up.

2. **Install the Custom Schematics Package**: In your project's root directory, install the custom schematics package by running the following command:

   ```sh
   npm install @samagra-x/schematics
   ```

3. Modify the contents of your `nest-cli.json` file to the following

   ```json
   {
     "$schema": "https://json.schemastore.org/nest-cli",
     "collection": "@samagra-x/schematics",
     "sourceRoot": "src",
     "compilerOptions": {
       "deleteOutDir": true
     }
   }
   ```

Now, You can use commands like nest generate like normal, along with arguments like `nest g <CUSTOME_STENCIL_SERVICE_NAME>` to generate custom service.
Currently supported services are:
- Prisma
- Monitoring Using Prometheus and Grafana
- Temporal
- Logging
- File Upload
npm package: @savio629/schematics-test
Description: schematics for stencil applcations
Latest version: 0.0.7

# Custom Schematics

Custom schematics can streamline the process of generating code and adding features to your Nest.js project. Follow these steps to use your custom schematics:

1. **Initialize Your Nest Project**: Make sure you have a Nest.js project set up.

2. **Install the Custom Schematics Package**: In your project's root directory, install the custom schematics package by running the following command:

   ```sh
   npm install @samagra-x/schematics
   ```

3. Modify the contents of your `nest-cli.json` file to the following

   ```json
   {
     "$schema": "https://json.schemastore.org/nest-cli",
     "collection": "@samagra-x/schematics",
     "sourceRoot": "src",
     "compilerOptions": {
       "deleteOutDir": true
     }
   }
   ```

Now, You can use commands like nest generate like normal, along with arguments like `nest g <CUSTOME_STENCIL_SERVICE_NAME>` to generate custom service.
Currently supported services are:
- Prisma
- Monitoring Using Prometheus and Grafana
- Temporal
- Logging
- File Upload
npm package: @savio629/schematicss
Description: schematics for stencil applcations
Latest version: 0.0.5

# Custom Schematics

Custom schematics can streamline the process of generating code and adding features to your Nest.js project. Follow these steps to use your custom schematics:

1. **Initialize Your Nest Project**: Make sure you have a Nest.js project set up.

2. **Install the Custom Schematics Package**: In your project's root directory, install the custom schematics package by running the following command:

   ```sh
   npm install @samagra-x/schematics
   ```

3. Modify the contents of your `nest-cli.json` file to the following

   ```json
   {
     "$schema": "https://json.schemastore.org/nest-cli",
     "collection": "@samagra-x/schematics",
     "sourceRoot": "src",
     "compilerOptions": {
       "deleteOutDir": true
     }
   }
   ```

Now, You can use commands like nest generate like normal, along with arguments like `nest g <CUSTOME_STENCIL_SERVICE_NAME>` to generate custom service.
Currently supported services are:
- Prisma
- Monitoring Using Prometheus and Grafana
- Temporal
- Logging
- File Upload
npm package: @savio629/stencil-cli
Description: Stencil cli for custom nest bootstrap
Latest version: 0.0.7

## Description

The Stencil CLI is a command-line interface tool that helps you to initialize, develop, and maintain your Nest applications. It assists in multiple ways, including scaffolding the project, serving it in development mode, and building and bundling the application for production distribution. It embodies best-practice architectural patterns to encourage well-structured apps.

The CLI works with [schematics](https://github.com/angular/angular-cli/tree/master/packages/angular_devkit/schematics), and provides built in support from the schematics collection at [@samagra-x/schematics](https://github.com/SamagraX-stencil/schematics).

Read more [here](https://stencil.samagra.io/cli/introduction).

## Installation

```
$ npm install -g @samagra-x/stencil-cli
```

## Usage

Learn more in the [official documentation](https://stencil.samagra.io/cli/introduction).

## Stay in touch

- Website - [https://stencil.samagra.io/](https://stencil.samagra.io/cli/introduction/)


## Mentions

Stencil is powered by the following open source projects
- [NestJS]
- [Prisma]
- [Prometheus]
- [Grafana]
- [Temporal]
- [nestjs-temporal]
- [nestjs-prometheus]

## License

Stencil is [MIT licensed](LICENSE).
npm package: @saviorishere/analysisui
Description: A components of Analisis on vue2.X
Author: saviorishere
Latest version: 0.1.4

# analysis-ui

> 基于Vue2.x和DevExtreme的前端组件库

# 项目目录
``` bash
.
├── dist                         # 压缩后文件目录
├── site                         # 项目结构目录
│   ├── App.vue                  # 单页应用父组件          
│   └── main.js                  # 单页应用启动入口文件
├── src                           # 开发目录
│   ├── assets                    # 静态文件：scss/image
│   ├── components                # 存放共用组件库
│   ├── index.js                  # 全局注册组件插件
│   └── style.js                  # 导入scss
├── index.html
├── package.json                  # 依赖管理
├── webpack.dev.js                #项目启动配置文件：npm run dev
├── webpack.config.js             #项目打包配置文件：npm run build
└── README.md                     #README
```

# Usage

## Install dependencies

```bash
  npm install
```
or

```bash
  yarn
```

## Serve with hot reload at localhost:8080

```bash
  npm run dev
```
or

```bash
  yarn dev
```

> 发布新版本时，执行打包压缩

## Build for production with minification

```bash
  npm run build
```
or

```bash
  yarn build
```
npm package: @savitar47/nestjs-eureka
Description: A NestJS module that integrate eureka-js-client
Author: F. Boisselier
Latest version: 2.0.3
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.


[![pipeline status](https://gitlab.com/fboisselier52/nestjs-eureka/badges/master/pipeline.svg)](https://gitlab.com/fboisselier52/nestjs-eureka/commits/master)

`nests-eureka` is a [NestJS](https://nestjs.com/) module that provides an integration with [eureka-js-client](https://github.com/jquatier/eureka-js-client#eureka-js-client)

## Getting Started

You need to import the `EurekaModule` in your application:

```js
EurekaModule.forRoot({
    eureka: {
      host: 'eureka-service',
      port: 8761,
      registryFetchInterval: 1000,
      servicePath: '/eureka/apps/',
      maxRetries: 3,
    },
    service: {
      name: 'my-service',
      port: 8080,
    },
}),
```

## Run Tests

```
npm run test
docker pull springcloud/eureka
docker run --rm -p 8761:8761 springcloud/eureka
npm run test:e2e
```
npm package: @savkit/readystore
Description: ReadyStore Core helps you build Stores based on pure Angular Signals or pure RxJs. A Store can work independently or be dependency-aware, relying on other Stores or facades if needed. It enables you to design clean data architectures on the UI layer, whic
Author: Andrii Svorak
Latest version: 0.1.9

# @savkit/readystore

> ⚠️ **Alpha Version Notice**  
> This package is currently in alpha and not ready for production use.  
> Beta and final releases are coming soon.

**ReadyStore Core** — dependency-aware state based on Angular Signals:
computes values only when all required data is ready.
If data is missing, computation is not performed.

- ✅ Signals-first API
- ✅ Dependency tracking
- ✅ Guarded / lazy evaluation (no compute until ready)
- ✅ TypeScript typings

## Install

```bash
npm i @savkit/readystore
npm package: @savla-dev/node-cache
Description: Simple caching for Node.js apps.
Author: Tackx
Latest version: 1.0.0

# node-cache

Simple in-memory caching for Node.js apps.

## Getting Started

Create a new instance of the cache, passing in the TTL for its items in seconds:

```ts
const cache = new Cache(900)
```

The following methods are exposed:

```ts
set(key: string, value: T): void
get(key: string): T | null
delete(key: string): void
// Clears all items from the cache
clear(): void
```

## Example usage

```ts
import { Cache } from '@savla-dev/node-cache'

const cache = new Cache<unknown>(900) // 15 minutes TTL

async function fetchWithCache(url: string): Promise<any> {
  const cachedData = cache.get(url)
  if (cachedData) {
    console.log('Returning cached data')
    return cachedData
  }

  console.log('Fetching new data')

  let response: Response
  try {
    response = await fetch(url)
  } catch (e) {
    throw new Error(`Error during fetch: ${e}`)
  }

  try {
    const data = await response.json()
    cache.set(url, data)
    return data
  } catch (e) {
    console.log(`Error during response parsing: ${e}`)
  }
}
```
npm package: @savla-dev/object-merge
Description: A utility for deeply merging two JS/TS objects into one.
Author: Tackx
Latest version: 1.0.15

# object-merge

Small, fast, simple and 0 dependency utility for merging two objects.

## Install

```bash
npm i @savla-dev/object-merge
```

## Usage

```ts
import { merge } from '@savla-dev/object-merge'

const object1 = {
  foo: 'bar',
  baz: [1, 2, 3],
  nestedObject: {
    also: 'works'
  }
}

const object2 = {
  key: 'value',
  baz: [4, 5, 6],
  nestedObject: {
    also: 'this value overrides the one from object1 due to this object having priority',
    anotherKey: 'anotherValue'
  }
}

// Returns the resultingObject below
merge(object1, object2, {
  priorityObject: 'right',
  useStructuredClone: true,
  mergeArrays: true
})

const resultingObject = {
  foo: 'bar',
  baz: [1, 2, 3, 4, 5, 6],
  nestedObject: {
    also: 'this value overrides the one from object1 due to this object having priority',
    anotherKey: 'anotherValue'
  },
  key: 'value'
}
```

## Options

- priorityObject
  - Specifies the object to take priority during merging and overriding values at identical keys.
  - `"left" | "right"`
- mergeArrays
  - Specifies whether arrays should be merged or overriden by the array from the priorityObject. True by default.
  - `boolean`
- useStructuredClone
  - Specifies whether to use the structuredClone() function to clone the object that is not priorityObject. True by default. If set to false, the `merge()` function will mutate the object not set as priorityObject.
  - `boolean`
npm package: @savo/css-utils
Description: Bootstrap 4 css utils
Author: savokiss
Latest version: 0.3.1

# css-utils
Bootstrap 4 css utilities

## Install

```
npm i @savo/css-utils -S
```

## Usage

```javascript
import '@savo/css-utils/dist/utilities.css'
```

## Docs
- [Utilities](http://getbootstrap.com/docs/4.1/utilities/borders/)
npm package: @savo/emitter
Description: Just the built-in emitter from Vue core
Author: savokiss
Latest version: 0.1.0

# emitter
Just the built-in emitter from Vue core

## Get Started

```bash
npm i @savo/emitter
```

## Usage
```js
import Emitter from '@savo/emitter'

const emitter = new Emitter()

emitter.$on('event', msg => {
  console.log('event fire', msg)
})

emitter.$emit('event', 'test msg')
```

## Links
- [Vue events](https://cn.vuejs.org/v2/api/#%E5%AE%9E%E4%BE%8B%E6%96%B9%E6%B3%95-%E4%BA%8B%E4%BB%B6)
npm package: @savo/js-utils
Description: JS utils collection
Author: savokiss
Latest version: 0.3.1

# js-utils

JS utils collection

## Install

```bash
npm i @savo/js-utils
```

## Usage

### Storage

```js
import { storage } from '@savo/js-utils'

storage.setItem(key, value) // value support object
storage.getItem(key) // auto convert to object
storage.removeItem(key)
storage.clear() // clear all
```

### Matrix

```js
import { Matrix } from '@savo/js-utils'

const matrix = new Matrix(list, rowCount, colCount)

matrix.getCol(0) // get the first col

matrix.getRow(1) // get the second row

```

### poller

#### using like setInterval

```js
import axios from 'axios'
import { poller } from '@savo/js-utils'

poller(retry => {
  axios.get(url).then(res => {
    retry() // retry when request finished
  })
}, 3000)
```

#### request retry

```js
import axios from 'axios'
import { poller } from '@savo/js-utils'

poller(retry => {
  axios.get(url).then(res => {
    if(res.data.ok) {
      doSomething(res)
    } else {
      retry() // only retry when request fail
    }
  })
}, 3000, 1.5)
```
npm package: @savo/queue
Description: Just a simple async queue
Author: savokiss
Latest version: 0.1.0

# queue
Just a simple async queue

# Installation

```console
npm i @savo/queue
```

# Usage

## Basic
```js
const q = new Queue(1)
const task1 = done => setTimeout(_ => {console.log('1'); done()}, 1000)
const task2 = done => setTimeout(_ => {console.log('2'); done()}, 1000)
const task3 = done => setTimeout(_ => {console.log('3'); done()}, 1000)
q.push(task1)
q.push(task2)
q.push(task3)

// console
// 1 - after 1000ms
// 2 - after 2000ms
// 3 - after 3000ms
```

## Concurrency=2
```js
const q = new Queue(2)
const task1 = done => setTimeout(_ => {console.log('1'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('2'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('3'); done()}, 1000)

// console
// 1 - after 1000ms
// 2 - after 1000ms
// 3 - after 2000ms
```

## AutoStart=false

```js
const q = new Queue(1, false)
const task1 = done => setTimeout(_ => {console.log('1'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('2'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('3'); done()}, 1000)
// queue wont start until you call q.start()
q.start()

// console
// 1 - after 1000ms
// 2 - after 2000ms
// 3 - after 3000ms
```

## Stop

```js
const q = new Queue(1)
const task1 = done => setTimeout(_ => {console.log('1'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('2'); done()}, 1000)
const task1 = done => setTimeout(_ => {console.log('3'); done()}, 1000)
// When you call stop after 1500 ms
q.stop()

// console
// 1 - after 1000ms
// 2 - after 2000ms
```

# API
```ts
interface Task {
  (done: Function): void;
}

declare class Queue {
  constructor(concurrency:number, autoStart = true);

  push(task: Task): void;

  start(): void;

  stop(): void;
}

export default Queue

```
# License
MIT
npm package: @savoirfairelinux/node-server-example
Description: Node Server Example
Author: Jean-Marie LEMETAYER
Latest version: 1.0.1

# Node Server Example

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

This is an example node server to test npm recipes on the [Yocto][yocto-url]
build system.

[yocto-url]: https://www.yoctoproject.org/
[npm-image]: https://img.shields.io/npm/v/@savoirfairelinux/node-server-example
[npm-url]: https://www.npmjs.com/package/@savoirfairelinux/node-server-example
npm package: @savorui/logview
Description: Log browsing components that support virtual scrolling and log collapse
Latest version: 1.0.4

# @savorui/logview
A high-performance UI log component with virtual scrolling, search functionality, and collapsible log sections, capable of handling large-scale datasets efficiently.

<img width="1308" alt="image" src="https://github.com/user-attachments/assets/f14a654c-4211-4152-af41-47e0127e39a9" />


## Install
```shell
npm install --save @savorui/logview
```


## Usage

```tsx
import Logview from '@savorui/logview';

const logs = ['hello world'];

<Logview logs={logs} theme='dark' />
```


## Dev
```
tnpm i
npm run dev
```

## API

| Name |	Type |	Description |	Required |
| --- | --- | --- | --- |
| logs | string[] | An array of log strings to be displayed. | Yes |
| theme | Theme | The theme to be applied to the log view. | No |
| width | number \| string | The width of the log view component. Can be a number or a string (e.g., "100%", "500px"). | No |
| height | number \| string | The height of the log view component. Can be a number or a string (e.g., "100%", "500px"). | No |
| currentLogIndex | number | The index of the currently selected log entry. | No |
| grouping | GroupingParams | Parameters for grouping logs. | No |
| toolbarRenderContainer| Element \| undefined \| null | A custom container element for rendering the toolbar. | No |
| oversize | boolean | Indicates whether the log view should handle oversize content. | No |
| downloadUrl | string | The URL for downloading logs. | No |
| externalUrl | string | An external URL related to the logs. | No |
| style | CSSProperties | Custom CSS styles to be applied to the log view component. | No |
| lang | 'zh' \| 'en' \| 'fr' \| 'de' \| 'es' \| 'ja' \| 'ko' | The language for the log view component. Supported languages include Chinese, English, French, German, Spanish, Japanese, and Korean. | No |
| advices | LogAdvice[] | An array of log advice objects. | No |
| loading | boolean | Indicates whether the log view is in a loading state. | No |
| lineLogParser | (log: string) => string | A function to parse each log line. | No |
| onTextSelectionChange | (text: string \| undefined) => void | A callback function that is triggered when the text selection changes. | No |
| renderTextSelectionBubble | (text: string \| undefined) => ReactNode | A function to render a custom bubble for text selection. | No |
| renderRightPanelContent | () => ReactNode | A function to render custom content in the right panel. | No |
| renderGroupName | (log: string) => string | A function to render a custom group name for each log entry. | No |
| onDownload | () => void | A callback function that is triggered when the download button is clicked. | No |
npm package: @savotije/openapi-to-joi
Description: Generates Joi schemas from an OpenAPI v3 documents.
Author: Savotije Petrovic
Latest version: 2.2.2

# openapi-to-joi

Generates Joi schemas from an OpenAPI v3 documents.

<span class="badge-npmversion"><a href="https://npmjs.org/package/@savotije/openapi-to-joi" title="View this project on NPM"><img src="https://img.shields.io/npm/v/@savotije/openapi-to-joi.svg" alt="NPM version" /></a></span>

## Installation

```sh
$ npm install @savotije/openapi-to-joi

$ yarn add @savotije/openapi-to-joi
```

## General Usage

Generates a file with Joi schemas from an OpenAPI 3 document.

For example, starting with this document:

```json
{
  "openapi": "3.0.0",
  ...
  "paths": {
    "/": {
      "get": {
        "operationId": "operation1",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "minLength": 5
            }
          }
        ],
        "responses": {
          "200": {
            "description": "200 Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Operation1Response"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Operation1Response": {
        "type": "object",
        "properties": {
          "email": {
            "type": "string",
            "description": "Valid email address",
            "format": "email"
          },
          "age": {
            "type": "integer",
            "description": "Age of adult",
            "format": "int32",
            "minimum": 18,
            "maximum": 99
          }
        }
      }
    }
  }
}
```

And running this command:

```sh
$ openapi-to-joi openapi.json --output generated.ts --skip-descriptions
```

Produces this `generated.ts`:

```typescript
import Joi from "joi"

export const schemas = {
  parameters: {
    operation1: { id: Joi.string().required().min(5) },
  },
  components: {
    Operation1Response: Joi.object({
      email: Joi.string().email({}),
      age: Joi.number().integer().max(99).min(18),
    }).unknown(),
  },
}
```

### Using the CLI

To view usage instructions for the CLI, use the `--help` command:

```sh
$ npm run openapi-to-joi --help

$ yarn openapi-to-joi --help
```
npm package: @savri/mcp
Description: MCP server for Savri analytics - use your analytics data with Claude
Author: Savri
Latest version: 0.1.1

# @savri/mcp

MCP (Model Context Protocol) server for Savri analytics. Use your website analytics data directly in Claude Desktop.

## Setup

### 1. Get your API key

Go to [Savri Dashboard > Settings > API](https://besokskollen.se/dashboard/settings/api) and create an API key with `read` scope (add `write` scope if you want to create goals/funnels).

### 2. Configure Claude Desktop

Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "savri": {
      "command": "npx",
      "args": ["@savri/mcp"],
      "env": {
        "SAVRI_API_KEY": "bk_your_api_key_here"
      }
    }
  }
}
```

### 3. Restart Claude Desktop

The Savri tools will now be available in Claude.

## Available Tools

| Tool | Description |
|------|-------------|
| `savri_list_sites` | List all your websites |
| `savri_get_stats` | Get visitor statistics (visitors, pageviews, bounce rate) |
| `savri_get_pages` | Get top pages |
| `savri_get_referrers` | Get traffic sources |
| `savri_get_countries` | Get visitor countries |
| `savri_list_goals` | List conversion goals |
| `savri_create_goal` | Create a new goal |
| `savri_list_funnels` | List conversion funnels |
| `savri_create_funnel` | Create a new funnel |

## Example Usage

Ask Claude things like:

- "Show me my website traffic for the last 30 days"
- "What are the top pages on example.com?"
- "Compare this week's traffic to last week"
- "Where is my traffic coming from?"
- "Create a goal for when users visit /thank-you"
- "Set up a checkout funnel: product page -> cart -> checkout -> confirmation"

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `SAVRI_API_KEY` | Yes | Your Savri API key |
| `SAVRI_API_URL` | No | Custom API URL (default: https://besokskollen.se/api/v1) |

## Development

```bash
# Install dependencies
npm install

# Build
npm run build

# Run locally
SAVRI_API_KEY=your_key node dist/index.js
```

## Links

- [Savri Dashboard](https://besokskollen.se/dashboard)
- [API Documentation](https://besokskollen.se/docs/public-api)
- [MCP Protocol](https://modelcontextprotocol.io)
npm package: @savvagent/astro
Description: Astro integration for Savvagent feature flags
Author: Savvagent
Latest version: 1.1.0

# @savvagent/astro

Astro integration for Savvagent with server-side rendering and middleware support.

## Installation

```bash
npm install @savvagent/astro
```

## Quick Start

### 1. Add Integration

```ts
// astro.config.mjs
import { defineConfig } from 'astro/config';
import savvagent from '@savvagent/astro';

export default defineConfig({
  integrations: [
    savvagent({
      config: {
        apiKey: process.env.SAVVAGENT_API_KEY,
        applicationId: process.env.SAVVAGENT_APP_ID,
      },
    }),
  ],
});
```

### 2. Use in Astro Components

```astro
---
import { isEnabled } from '@savvagent/astro';

const showNewLayout = await isEnabled('new-layout', {
  user_id: Astro.cookies.get('user_id')?.value,
});
---

{showNewLayout ? (
  <NewLayout />
) : (
  <OldLayout />
)}
```

## API Reference

### Server-Side Functions

#### `isEnabled(flagKey, context?)`

Check if a flag is enabled.

```astro
---
import { isEnabled } from '@savvagent/astro';

const enabled = await isEnabled('my-feature');
---
```

#### `evaluate(flagKey, context?)`

Get detailed evaluation result.

```astro
---
import { evaluate } from '@savvagent/astro';

const result = await evaluate('premium-features');
const { value, reason, metadata } = result;
---
```

#### `withFlag(flagKey, callback, context?)`

Execute code conditionally.

```astro
---
import { withFlag } from '@savvagent/astro';

const data = await withFlag('use-new-api', async () => {
  return await fetchFromNewAPI();
});
---
```

#### `evaluateForRequest(request, flagKey, context?)`

Evaluate with automatic request context.

```astro
---
import { evaluateForRequest } from '@savvagent/astro';

const showBeta = await evaluateForRequest(Astro.request, 'beta-ui');
---
```

### Middleware

Create middleware for flag-based routing:

```ts
// src/middleware.ts
import { sequence } from 'astro/middleware';
import { createFlagMiddleware } from '@savvagent/astro';

const flagMiddleware = createFlagMiddleware({
  'maintenance-mode': {
    redirect: '/maintenance',
  },
  'beta-access': {
    rewrite: (url) => '/beta' + url.pathname,
  },
});

export const onRequest = sequence(flagMiddleware);
```

## Using with UI Frameworks

Astro supports multiple UI frameworks. Use the appropriate SDK in your islands:

### React Islands

```astro
---
// Import server-side
import { isEnabled } from '@savvagent/astro';
const serverFlag = await isEnabled('ssr-feature');
---

<!-- Client-side React island -->
<ReactComponent client:load>
  {/* Use @savvagent/react hooks inside */}
</ReactComponent>
```

### Vue Islands

```astro
<VueComponent client:load>
  {/* Use @savvagent/vue composables inside */}
</VueComponent>
```

## License

MIT
npm package: @savvagent/mcp-dynatrace
Description: Savvagent Dynatrace MCP integration - Connect feature flags with Dynatrace APM and monitoring
Author: Rob Hicks
Latest version: 1.0.1

# @savvagent/mcp-dynatrace

Dynatrace MCP integration for Savvagent. Exposes Dynatrace APM and monitoring data via MCP tools.

## Features

- **get_problems**: Get active problems/incidents
- **get_problem_details**: Get detailed problem information
- **get_services**: List monitored services
- **get_service_metrics**: Get service metrics
- **get_hosts**: List monitored hosts
- **get_logs**: Query logs
- **get_synthetic_monitors**: Get synthetic monitor status
- **get_service_health**: Get overall service health
- **get_events**: Get events

## Installation

```bash
npm install @savvagent/mcp-dynatrace
```

## Quick Start

```typescript
import { DynatraceMCPServer } from '@savvagent/mcp-dynatrace';
import { createHttpHandler } from '@savvagent/mcp-sdk';
import express from 'express';

const server = new DynatraceMCPServer(
  { name: 'dynatrace-mcp', version: '1.0.0' },
  {
    environmentUrl: process.env.DT_ENV_URL!,
    apiToken: process.env.DT_API_TOKEN!,
    managementZone: 'production',
  }
);

await server.initialize();

const app = express();
app.use(express.json());

app.post('/mcp', createHttpHandler(server, {
  auth: { token: process.env.MCP_AUTH_TOKEN! }
}));

app.listen(3000);
```

## Configuration

```typescript
interface DynatraceConfig {
  environmentUrl: string;    // Dynatrace environment URL
  apiToken: string;          // API token
  managementZone?: string;   // Default management zone
}
```

## Environment Variables

```bash
MCP_AUTH_TOKEN=your-mcp-token
DT_ENV_URL=https://abc12345.live.dynatrace.com
DT_API_TOKEN=your-dynatrace-token
DT_MANAGEMENT_ZONE=production
```

## License

MIT
npm package: @savvagent/mcp-splunk
Description: Savvagent Splunk MCP integration - Connect feature flags with Splunk log analytics and monitoring
Author: Rob Hicks
Latest version: 1.0.1

# @savvagent/mcp-splunk

Splunk MCP integration for Savvagent. Exposes Splunk log analytics via MCP tools using StreamableHTTP transport.

## Features

- **search_logs**: Search logs using SPL queries
- **get_errors**: Fetch error-level logs
- **get_log_patterns**: Get aggregated log patterns
- **get_anomalies**: Detect log anomalies
- **get_saved_searches**: List saved searches
- **run_saved_search**: Execute saved searches
- **get_alerts**: Get triggered alerts
- **get_service_health**: Analyze service health from logs

## Installation

```bash
npm install @savvagent/mcp-splunk
```

## Quick Start

```typescript
import { SplunkMCPServer } from '@savvagent/mcp-splunk';
import { createHttpHandler } from '@savvagent/mcp-sdk';
import express from 'express';

const server = new SplunkMCPServer(
  { name: 'splunk-mcp', version: '1.0.0' },
  {
    host: process.env.SPLUNK_HOST!,
    token: process.env.SPLUNK_TOKEN!,
    defaultIndex: 'main',
  }
);

await server.initialize();

const app = express();
app.use(express.json());

app.post('/mcp', createHttpHandler(server, {
  auth: { token: process.env.MCP_AUTH_TOKEN! }
}));

app.listen(3000);
```

## Configuration

```typescript
interface SplunkConfig {
  host: string;              // Splunk host URL
  token: string;             // Auth token
  defaultIndex?: string;     // Default index
  defaultSourcetype?: string; // Default sourcetype
}
```

## Environment Variables

```bash
MCP_AUTH_TOKEN=your-mcp-token
SPLUNK_HOST=https://splunk.example.com:8089
SPLUNK_TOKEN=your-splunk-token
SPLUNK_INDEX=main
```

## License

MIT
npm package: @savvagent/solid
Description: SolidJS SDK for Savvagent feature flags with reactive primitives
Author: Savvagent
Latest version: 1.1.0

# @savvagent/solid

SolidJS SDK for Savvagent with reactive primitives (signals and resources).

## Installation

```bash
npm install @savvagent/solid
```

## Quick Start

```tsx
import { SavvagentProvider, createFlag } from '@savvagent/solid';
import { Show } from 'solid-js';

function App() {
  return (
    <SavvagentProvider config={{ apiKey: 'sdk_...' }}>
      <MyFeature />
    </SavvagentProvider>
  );
}

function MyFeature() {
  const flag = createFlag('new-feature');

  return (
    <Show when={!flag.loading()} fallback={<div>Loading...</div>}>
      <Show when={flag.value()} fallback={<OldFeature />}>
        <NewFeature />
      </Show>
    </Show>
  );
}
```

## API Reference

### `createFlag(flagKey, options)`

Create a reactive flag with full state.

```tsx
const flag = createFlag('new-feature', {
  context: { user_id: userId() },
  defaultValue: false,
  realtime: true,
});

// Access values
flag.value();   // boolean
flag.loading(); // boolean
flag.error();   // Error | null
flag.refetch(); // force re-evaluation
```

### `createFlagValue(flagKey, options)`

Simple accessor for flag value only.

```tsx
const isEnabled = createFlagValue('new-feature');

return <Show when={isEnabled()}><NewFeature /></Show>;
```

### `createUserSignals()`

Manage user identification.

```tsx
const [userId, setUserId] = createUserSignals();

createEffect(() => {
  setUserId(currentUser()?.id || null);
});
```

## License

MIT
npm package: @savvagent/svelte
Description: Svelte SDK for Savvagent feature flags with stores and runes
Author: Savvagent
Latest version: 1.1.0

# @savvagent/svelte

Svelte SDK for Savvagent with stores and real-time updates. Compatible with Svelte 4 and 5.

## Installation

```bash
npm install @savvagent/svelte
```

## Quick Start

```svelte
<!-- +layout.svelte -->
<script>
import { initSavvagent } from '@savvagent/svelte';

initSavvagent({
  apiKey: 'sdk_...',
  applicationId: 'your-app-id',
});
</script>

<slot />
```

## Stores

### `createFlagStore(flagKey, options)`

Full flag state with loading and error handling.

```svelte
<script>
import { createFlagStore } from '@savvagent/svelte';

const featureFlag = createFlagStore('new-feature', {
  context: { user_id: $user?.id },
  defaultValue: false,
  realtime: true,
});
</script>

{#if $featureFlag.loading}
  <p>Loading...</p>
{:else if $featureFlag.value}
  <NewFeature />
{:else}
  <OldFeature />
{/if}
```

### `createFlag(flagKey, options)`

Simple boolean store.

```svelte
<script>
import { createFlag } from '@savvagent/svelte';

const isEnabled = createFlag('new-feature');
</script>

{#if $isEnabled}
  <NewFeature />
{/if}
```

### `createUserIdStore()`

Manage user identification.

```svelte
<script>
import { createUserIdStore } from '@savvagent/svelte';

const userId = createUserIdStore();

// Set on login
$userId = user.id;

// Clear on logout
$userId = null;
</script>
```

## Functions

### `trackError(flagKey, error, context?)`

Track errors with flag context.

```svelte
<script>
import { trackError } from '@savvagent/svelte';

async function handleAction() {
  try {
    await doSomething();
  } catch (error) {
    trackError('new-feature', error);
  }
}
</script>
```

## License

MIT
npm package: @savvagent/sveltekit
Description: SvelteKit SDK for Savvagent feature flags with server and client support
Author: Savvagent
Latest version: 1.1.0

# @savvagent/sveltekit

SvelteKit SDK for Savvagent with server-side load functions and client-side stores.

## Installation

```bash
npm install @savvagent/sveltekit
```

## Quick Start

### Server-Side (Load Functions)

```ts
// src/hooks.server.ts
import { initSvelteKitServer } from '@savvagent/sveltekit/server';

initSvelteKitServer({
  apiKey: process.env.SAVVAGENT_API_KEY!,
});
```

```ts
// +page.server.ts
import { isEnabled } from '@savvagent/sveltekit/server';

export async function load({ cookies }) {
  const enabled = await isEnabled('new-feature', {
    user_id: cookies.get('user_id'),
  });

  return { enabled };
}
```

### Client-Side (Stores)

```svelte
<!-- +layout.svelte -->
<script>
import { initSavvagent } from '@savvagent/sveltekit';

initSavvagent({
  apiKey: import.meta.env.VITE_SAVVAGENT_API_KEY,
});
</script>
```

```svelte
<!-- +page.svelte -->
<script>
import { createFlag } from '@savvagent/sveltekit';

const isEnabled = createFlag('client-feature');
</script>

{#if $isEnabled}
  <NewFeature />
{/if}
```

## API Reference

### Server-Side (`@savvagent/sveltekit/server`)

- `initSvelteKitServer(config)` - Initialize server client
- `isEnabled(flagKey, context?)` - Check if flag is enabled
- `evaluate(flagKey, context?)` - Get detailed result
- `evaluateForEvent(event, flagKey, context?)` - Evaluate with event context
- `getEventContext(event, overrides?)` - Extract context from event
- `trackError(flagKey, error, context?)` - Track errors

### Client-Side

All stores and functions from `@savvagent/svelte` are available.

## License

MIT
npm package: @savvagent/tea
Description: tiny-encryption-algorithm =========================
Latest version: 2.0.29

tiny-encryption-algorithm
=========================

Javascript implementation of the [XTEA block cipher algorithm](https://en.wikipedia.org/wiki/XTEA).

Comes in 3 flavors, IIFE, CJS and ES2015.

Assets are in the dist folder.

Install using npm or yarn.
npm package: @savvagent/tiny-i18next
Description: A lightweight translation module for modern Javascript
Author: rob@savvagent.com
Latest version: 2.1.1

# @savvagent/tiny-i18next

This is a tiny and simple class for i18n translations. It supports placeholders and various plurals.
It requires a modern browser or node 16.x or greater

## Installation

Use npm, pnpm or yarn to install it.

```shell
pnpm add @savvagent/tiny-i18next
```

## Use

```JavaScript
import I18next from '@savvagent/tiny-i18next';
const enTranslations = {
  "cancel": "Cancel",
  "checkout": "Checkout",
  "modal_body": "This is the modal body",
  "open": "Open",
  "title": "Find"
}

const t = new I18next(enTranslations)

const t = new I18next({ name: "George" });
const userName = t('name') // George

```

See src/test/I18next.spec.ts for other examples
npm package: @savvagent/tiny-url-template
Description: Lightweight Javascript library which complies with RFC 6570 for expanding URL Templates.
Author: rob@savvagent.org
Latest version: 1.0.1

tiny-url-template
=============

tiny-url-template is yet another Javascript library for expanding URI templates according to [RFC-6570](http://tools.ietf.org/html/rfc6570).
Note it doesn't do everything specified in the RFC and deals with expansion only of URI templates.

# Installation

The distribution assets are prebuild and are located in the `dist` directory.

tiny-url-template depends on [tiny-uri](https://github.com/robhicks/tiny-uri).

```shell
npm install tiny-uri tiny-url-template

# or

yarn add tiny-uri tiny-url-template

# or

bower instal https://github.com/robhicks/tiny-url-template.git

```

# Use

You can use the library in the browser or on NodeJs.

In the browser you can load dist/tiny-url-template.iife.js in
a script tag, or if you have a browser which supports ES-2015, or are using an es6 aware bundler like RollupJs, you can import it into your
entry file using Node's resolution algorithm (rollup-plugin-node-resolve).

In NodeJs, require it as usual.

# Examples

See the tests in spec/tiny-url-template.test.js.

# Development

The library requires a build step: `npm run build`

To run the tests: `npm run jasmine`
npm package: @savvagent/vue
Description: Vue SDK for Savvagent feature flags with Composition API
Author: Savvagent
Latest version: 1.1.0

# @savvagent/vue

Vue 3 SDK for Savvagent with Composition API composables.

## Installation

```bash
npm install @savvagent/vue
```

## Quick Start

```vue
<script setup>
import { createApp } from 'vue';
import { SavvagentPlugin, useFlag } from '@savvagent/vue';
import App from './App.vue';

// Install plugin
const app = createApp(App);
app.use(SavvagentPlugin, {
  apiKey: 'sdk_...',
  applicationId: 'your-app-id',
});
app.mount('#app');
</script>
```

## Composables

### `useFlag(flagKey, options)`

```vue
<script setup>
import { useFlag } from '@savvagent/vue';

const { value: isEnabled, loading } = useFlag('new-feature', {
  context: { user_id: user.value?.id },
  defaultValue: false,
  realtime: true,
});
</script>

<template>
  <div v-if="loading">Loading...</div>
  <NewFeature v-else-if="isEnabled" />
  <OldFeature v-else />
</template>
```

### `useSavvagent()`

Get the client instance for advanced usage.

### `useUser()`

Manage user identification.

```vue
<script setup>
import { useUser } from '@savvagent/vue';
import { watch } from 'vue';

const { setUserId } = useUser();

watch(currentUser, (user) => {
  setUserId(user?.id || null);
});
</script>
```

### `useTrackError(flagKey, context)`

Track errors with flag context.

## License

MIT