open-index/open-npm huggingface dataset:
npm package: @kaicmo/gate
Description: Zehrava Gate SDK — safe commit layer for AI agents
Latest version: 0.1.1

# @kaicmo/gate

**The commit checkpoint between AI agents and production systems.**

Every agent write goes through the same path: `propose → policy → approve → deliver → audit`. No direct commits. No silent writes.

→ [zehrava.com](https://zehrava.com) · [GitHub](https://github.com/cgallic/zehrava-gate)

## Install

```bash
npm install @kaicmo/gate
```

## Quickstart

Run the Gate server locally:

```bash
npx zehrava-gate --port 4000
```

Use the SDK:

```js
const { Gate } = require('@kaicmo/gate')

const gate = new Gate({
  endpoint: 'http://localhost:4000',
  apiKey: 'YOUR_KEY'   // from POST /v1/register
})

// Propose an action — Gate evaluates policy before anything writes
const p = await gate.propose({
  payload:     './leads.csv',
  destination: 'salesforce.import',
  policy:      'crm-low-risk',
  recordCount: 847
})

console.log(p.status)
// "pending_approval" — 847 > 100 threshold
// "approved"         — auto-approved by policy
// "blocked"          — destination not in allowlist

// Deliver exactly once (after approval)
await gate.deliver({ proposalId: p.proposalId })
// Second call returns 409 — one-time delivery enforced
```

## API

```js
gate.propose({ payload, destination, policy, recordCount, metadata })
gate.approve({ proposalId })
gate.reject({ proposalId, reason })
gate.deliver({ proposalId })
gate.verify({ proposalId })
```

## What Gate governs

Gate does not validate business logic. It answers four questions before any write reaches production:

1. **Who sent this?** — verified agent identity
2. **Where is it going?** — destination allowlists
3. **Should it be allowed?** — shared policy rules (YAML)
4. **Who approved it?** — centralized approval queue + audit trail

## Policy example

```yaml
id: crm-low-risk
destinations: [salesforce.import, hubspot.contacts]
auto_approve_under: 100
require_approval_over: 100
expiry_minutes: 60
delivery: one_time
```

Policies are shared YAML files. Same rules across every agent, every framework.

## Why not just use LangSmith / Guardrails / AgentOps?

Those tools are observability and content safety — they tell you what happened or validate LLM outputs. Gate governs the **write path**: whether an agent output is allowed to become a production write, and who approved it.

## Self-hosting

Gate is MIT licensed and self-hostable. Run it on your own infrastructure:

```bash
git clone https://github.com/cgallic/zehrava-gate
cd zehrava-gate/packages/gate-server
npm install
npm start
```

## Links

- **Live demo**: [zehrava.com/demo](https://zehrava.com/demo)
- **Approval dashboard**: [zehrava.com/dashboard](https://zehrava.com/dashboard)
- **Docs**: [zehrava.com](https://zehrava.com)
- **Server package**: [zehrava-gate on npm](https://npmjs.com/package/zehrava-gate)
npm package: @kaicurry/redux-graph
Description: Redux graph database.
Author: Kai Curry
Latest version: 2.6.7

# redux-graph

Really basic graph database with entity and triple storage with some helper functions to join it all together. The module loosely follows the Hexastore approach. Six indices are created for every triple, in order to access them as fast as it is possible.

Each entity must have a unique `id` field and a `type` field.
The triple `id` is in the format of `[ subjectId, predicate, objectId ]`.

## Reducer

The reducer is default export. Uses `cape-redux.createReducer` internally.

```javascript
import graph from 'redux-graph'
const reducerIndex = {
  graph,
}
const reducer = combineReducers(reducerIndex)
const store = createStore(reducer)
```

## Entity Actions

* entityDel
* entityPut
* entityPutAll
* entityUpdate

## Triple Actions

* tripleDel
* triplePut
* triplePutAll

## Selectors

* entitySelector
* `entityTypeSelector('Person')`

## Helper functions.

* `create(dispatch, item)` will create required triples and objects.
* `selectorCreate(selector)(dispatch, getState)` For when you need a thunk action to create entity based on selector.
* `createIfNew()` will dispatch new entity if it doesn't have an id field.
* `createTriple()` will dispatch new entities and triples.
* `nextId()` generate a new random key. Probably unique.
* `isEntity()` is the object an entity.
* `isEntityCreated()` does the entity have an id field. Second arg to check dateCreated prop.
* `isTriple()` valid triple object.
* `insertFields()` add fields (id and dateCreate) required for save.
* `rebuildEntity()` adds predicate fields and entity references back into a single object.
* `entityDomainIncludes()` adds `domainIncludes` property to entity that includes entities that reference it.
* `entityMatch(object, source)` Only checks that object and source have same `id` and `type` prop values.
* `entityMatches(source)(object)` Define source first.
npm package: @kaiei/echart-react-components
Description: echarts-react-components
Latest version: 0.0.1

# echarts-react-components

---
echarts webpack dynamic imports solution for React project 
## introduce
鉴于react项目中引入整个echarts体积偏大,so 提供了一个 echarts 动态引入方案

## install

```
$npm i @kaiei/echart-react-components
```

## Usage

#### step1 修改项目 webpack 位置，增加一条 chunkFilename(为了给动态引入的文件起名)

```
output: {
      filename: '[name].bundle.js',
+     chunkFilename: '[name].bundle.js',
      path: path.resolve(__dirname, 'dist')
    }
```

#### step2

```js
import React, { Component } form 'react';
import AsyncComponent from 'echarts-react-components/lib/async-component';
const Pie = AsyncComponent(() => import(/* webpackChunkName: "Pie" */'echarts-react-components/lib/pie'));

```

### basic use

```js
class Demo extends React.Component {
  onChartClick = () => {};

  render() {
    const onEvents = {
      click: this.onChartClick,
    };
    return <Pie option={pieOption} onEvents={onEvents} style={{ height: 300, width: 500 }} />;
  }
}
```

## Development

```
npm install
npm start
```

## publish
```
$npm run pub
```

## License

echarts-react-components is released under the MIT license.
npm package: @kaif9711/reactjs-tabbedpane-component
Description: A tabbed pane component using React.js
Author: adafycheng
Latest version: 1.0.21

# reactjs-tabbedpane-component

> A tabbed pane component using React.js

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

## Install

```bash
npm install --save reactjs-tabbedpane-component
```

## Usage

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

import TabbedPane from 'reactjs-tabbedpane-component'
import 'reactjs-tabbedpane-component/dist/index.css'

const contentData = {
  contents: [
    {
      subject: 'Overview',
      text: 'This is content of Overview'
    },
    {
      subject: 'Assumptions',
      text: '<ul><li>Assumption 1</li><li>Assumption 2</li><li>Assumption 3</li><li>Assumption 4</li></ul>'
    },
    {
      subject: 'Technical Design',
      text: 'This is content of Technical Design'
    }
  ]
}

class Example extends Component {
  render() {
    return <TabbedPane data={contentData} />
  }
}
```

![Example Image 1](example/images/example1.png)

![Example Image 2](example/images/example2.png)

## API

`<TabbedPane>`

### props

* *data*: JSON defining the tabs.  HTML tags are supported.

## License

MIT © [adafycheng](https://github.com/adafycheng)
npm package: @kaifronsdal/transcript-viewer
Description: A web-based viewer for AI conversation transcripts with rollback support
Author: Kai Fronsdal
Latest version: 1.0.29

# Transcript Viewer

A web-based viewer for AI conversation transcripts with support for rollbacks, branching conversations, and detailed analysis.

## Quick Start (One Command)

### Option 1: NPX (Recommended)
Run the transcript viewer locally without cloning or building:

```bash
npx @kaifronsdal/transcript-viewer@latest --dir ./transcripts -f
```

### Option 2: RunPod Deployment
For RunPod deployment, use the following command to make the service accessible from all interfaces:

```bash
npx @kaifronsdal/transcript-viewer@latest --host 0.0.0.0 --port 8080 --dir /workspace/transcripts -f
```

**RunPod Setup:**
1. Create a new RunPod instance
2. Expose port 8080 in your RunPod configuration
3. Upload your transcript files to `/workspace/transcripts/` (or specify a different directory)
4. Run the command above
5. Access your service via the RunPod public URL

## Development

If you want to develop or customize the viewer:

### Prerequisites
- Node.js 18+ 
- npm or pnpm

### Setup
```bash
git clone git@github.com:safety-research/alignment-auditing-agent.git
cd alignment-auditing-agent
git checkout -b website
npm install
```

### Development Server
```bash
npm run dev
```

### Building
```bash
npm run build
```

### Preview Production Build
```bash
npm run preview
```