open-index/open-npm huggingface dataset:
npm package: @railtownai/browser
Description: @railtownai/browser is a library that provides browser integrations with Railtown AI
Author: Railtown AI
Latest version: 2.0.29

# Railtown AI JavaScript Browser Integration

This package provides a JavaScript API for interacting with Railtown AI from a web browser.

## Getting Started

1. Sign up on Railtown AI and create a new project.
1. Copy your Railtown API Key from the project configuration page.
1. Use the following code snippet in your `<head>`:

```html
<!-- Railtown -->
<script src="https://railtownazureb2c.blob.core.windows.net/cdn/railtown.min-latest.js"></script>
<script>
  window.RailtownAI && RailtownAI.install("YOUR_RAILTOWN_TOKEN");
</script>
```

## Configuration

The `install` function takes an optional configuration object as a second argument. The following options are available:

### `ignoreErrors`

Specify a list of error messages to ignore. This is useful for ignoring errors that are not actionable, such as network errors. The default value is `[]`.

```javascript
RailtownAI.install("YOUR_RAILTOWN_TOKEN", {
  ignoreErrors: ["Network Error", /Exact Message/],
});
```
npm package: @railtownai/bunyan-railtownai
Description: A bunyan stream to ship your logs to railtown.ai
Author: railtown.ai
Latest version: 1.0.10


# bunyan-railtownai
bunyan-railtownai is a bunyan stream to ship your logs to railtown.ai

## Install
```console
$ npm install @railtownai/bunyan-railtownai
```

## Options
- **token**: Your railtown token *[required]*

## Usage
```javascript
const bunyan = require('bunyan');
const BunyanRailtownAi = require('@railtownai/bunyan-railtownai');


const log = bunyan.createLogger({
  name: 'myapp',
  stream: new BunyanRailtownAi({
    token: 'your_token_here',
  }),
});

//or use environment variable 'RAILTOWN_TOKEN' and call it without the token key

const log = bunyan.createLogger({
  name: 'myapp',
  stream: new BunyanRailtownAi(),
});
```

## Manually Logging Errors with additional properties
Import bunyanLogger and use as follows:
```javascript
try {
  // code to try 
} catch (error) {
    const logError = {
      err: { message: error.message, stack: error.stack },
      userId: '123456789',
      projectId: 'abcdefg'
    };

    bunyanLogger.error(logError, error.message);
}
npm package: @railtownai/log4js-railtownai
Description: A log4js appender to ship your logs to railtown.ai
Author: railtown.ai
Latest version: 1.0.2

# Log4JS - Railtownai Appender

## Installation

```bash
npm i @railtownai/log4js-railtownai
```

## Configuration

- `type` - `@railtownai/log4js-railtownai`
- `token` - `string` - railtown token

## Example

```javascript
log4js.configure({
  appenders: {
    railtownai: {
      type: '@railtownai/log4js-railtownai',
      token: 'your_token_here',
    },
  },
  categories: { default: { appenders: ['railtownai'], level: 'error' } },
});
```

## Manually Logging Errors with additional properties
Import log4jsLogger and use as follows:
```javascript
try {
  // code to try 
} catch (error) {
    const logError = {
      err: error,
      userId: '123456789',
      projectId:'abcdefg'
    };

  log4jsLogger.error(logError);
}
```

This will send log messages to [railtownai](https://app.railtown.ai/).
npm package: @railtownai/loglevel-railtownai
Description: ## Installation
Author: railtown.ai
Latest version: 1.0.1

# loglevel Railtownai Plugin

## Installation

```bash
npm i @railtownai/loglevel-railtownai
```

## Configuration

- `logger` - `object` - loglevel instance to be extended
- `options` - `object` - used to add your railtown token

## Example

```javascript
const loglevelRailtown = require('@railtownai/loglevel-railtownai');

loglevelRailtown(logger, {
  token: 'your_token_here',
});

//or use environment variable 'RAILTOWN_TOKEN' and call it without the token key

loglevelRailtown(logger);
```
## Manually Logging Errors with additional properties
Import loglevelLogger and use as follows:
```javascript
try {
  // code to try 
} catch (error) {
    const logError = {
      err: error,
      userId: '123456789',
      projectId:'abcdefg'
    };

  loglevelLogger.error(logError);
}
```

This will send log messages to [railtownai](https://app.railtown.ai/).
npm package: @railtownai/pino-railtownai
Description: A Pino Transport to ship your logs to railtown.ai
Author: railtown.ai
Latest version: 1.0.4

# pino-railtownai

A [Pino v7+ transport](https://github.com/pinojs/pino/blob/master/docs/transports.md#v7-transports) to ship your logs to [Railtownai](https://www.railtown.ai/)

## Installation

```
npm i @railtownai/pino-railtownai
```

## Options
- **token**: Your railtown token *[required]*

## Usage

```javascript
import pino from 'pino'

const logger = pino({
  transport: {
    target: '@railtownai/pino-railtownai',
    options: {
      token: 'your_token_here'
    }
  }
})

//or use environment variable 'RAILTOWN_TOKEN' and call it without the token key

const logger = pino({
  transport: {
    target: '@railtownai/pino-railtownai'
  }
})
```

## Manually Logging Errors with additional properties
Import pinoLogger and use as follows:
```javascript
try {
  // code to try 
} catch (error) {
  pinoLogger.error({
    err: error,
    userId: '123456789',
    projectId: 'abcdefg'
  });
}
npm package: @railtownai/railengine-ingest
Description: JavaScript/TypeScript SDK for Railtown AI Rail Engine - Ingestion
Author: Railtown AI
Latest version: 0.0.5

# @railtownai/railengine-ingest

JavaScript/TypeScript SDK for [Railtown AI Rail Engine](https://railengine.ai/) - Ingestion package. This package provides a simple interface for publishing data to Rail Engine and handling webhook events.

## Installation

```bash
npm install @railtownai/railengine-ingest
```

## Requirements

- Node.js 20+
- TypeScript 5.0+ (optional, but recommended)

## Quick Start

### Basic Usage

```typescript
import { RailEngineIngest } from "@railtownai/railengine-ingest";
import { v4 as uuidv4 } from "uuid";

// Initialize client
// ENGINE_TOKEN is read from environment variable automatically
const client = new RailEngineIngest();

const blogPost = {
  id: uuidv4(),
  title: "My blog post",
  content: "This is my blog post",
  date: new Date().toISOString()
};

// Send data
await client.upsert(blogPost);
```

## License

MIT.
npm package: @railtownai/railtracks-timeline
Description: A timeline visualizer for Railtracks agentic flows
Author: Railtown AI
Latest version: 0.0.23

# Railtracks Timeline Visualizer

A React-based timeline visualizer for Railtracks agentic flows

## 🚀 Quick Start

### As an NPM Package

1. **Install the package:**

   ```bash
   npm install @railtownai/railtracks-timeline
   ```

2. **Import and use in your React app:**

   ```tsx
   import { TimelineVisualizer } from "@railtownai/railtracks-timeline";
   import { AgentRun } from "@railtownai/railtracks-timeline";

   function App() {
     // Option 1: Pass JSON string (backward compatible)
     const jsonData = JSON.stringify(agentRunData);

     // Option 2: Pass AgentRun object directly (new feature)
     const agentRunData: AgentRun = {
       name: "My Agent",
       run_id: "run-456",
       start_time: 1725792000,
       end_time: 1725795600,
       status: "Completed",
       nodes: [
         // ... your agent nodes
       ]
     };

     return (
       <div>
         {/* Using JSON string */}
         <TimelineVisualizer data={jsonData} />

         {/* Using AgentRun object directly */}
         <TimelineVisualizer data={agentRunData} />
       </div>
     );
   }
   ```

### Optional `style` Prop

You can specify the timeline view style using the optional `style` prop:

```tsx
<TimelineVisualizer data={agentRunData} style="tree" />
```

or

```tsx
<TimelineVisualizer data={agentRunData} style="flat" />
```

If omitted, the default is `flat`.

## 🎨 Features

- **Configurable View Style**: Use the `style` prop to switch between `tree` and `flat` timeline views

- **Interactive Flow Visualization**: Visualize agentic flows with nodes and edges in a timeline view
- **Timeline Navigation**: Step through the flow execution timeline
- **Flexible Data Input**: Accept both JSON strings and AgentRun objects directly
- **Type Safety**: Full TypeScript support with AgentRun interface
- **Responsive Design**: Works on different screen sizes

## 📄 License

MIT

## 📞 Support

For issues and questions, please [open an issue on GitHub](https://github.com/RailtownAI/railtracks-timeline/issues).
npm package: @railtownai/railtracks-visualizer
Description: A visualizer for Railtracks agentic flows
Author: Railtown AI
Latest version: 0.0.65

# Railracks Visualizer

[![Tests](https://github.com/RailtownAI/railtracks-visualizer/actions/workflows/ci.yaml/badge.svg)](https://github.com/RailtownAI/railtracks-visualizer/actions/workflows/ci.yaml)

A React-based visualizer for Railtracks agentic flows

## 🚀 Quick Start

### As an NPM Package

1. **Install the package:**

   ```bash
   npm install @railtownai/railtracks-visualizer
   ```

2. **Import and use in your React app:**

   ```tsx
   import { Visualizer } from '@railtownai/railtracks-visualizer';

   function App() {
     const data = {
       nodes: [...],
       edges: [...],
       stamps: [...]
     };

     return (
       <Visualizer
         flowData={data}
         width="100%"
         height="800px"
         showTimeline={false}
         defaultZoom={1.2}
         defaultPan={{ x: 0, y: 0 }}
       />
     );
   }
   ```

## 🎨 Features

- **Interactive Flow Visualization**: Visualize agentic flows with nodes and edges
- **Auto-layout**: Automatic positioning of nodes in a tree structure
- **Inspection Panel**: Detailed view of nodes and edges
- **Portable Styling**: Uses emotion for self-contained, portable styles
- **Graceful Theme Handling**: Works out of the box with default light theme, no ThemeProvider required
- **Dark Mode Support**: Full dark mode compatibility with automatic theme detection

### Basic Usage (No ThemeProvider Required)

```tsx
import { Visualizer } from "@railtownai/railtracks-visualizer";

// Works out of the box with default light theme
<Visualizer flowData={data} />;
```

## 🔧 Development

1. `npm install`
2. `npm run build`
3. `npm test`
4. `npm start` - This should open up Storybook UI at `http://localhost:6006`

## 📦 Exportable Components

We allow exporting UI components from AgentHub that can be used in external React applications across different environments (e.g. web, mobile, desktop, chrome extensions, etc.).

In order to use them, you'll need to ensure you pass the correct DTOs to the components.

For example, if you want to use the EvaluationsTable component, you'll need to pass the correct Evaluation DTOs to the component.

```tsx
import type { Evaluation as EvaluationDto } from "@railtownai/railtracks-visualizer";
<EvaluationsTable evaluations={evaluations as EvaluationDto[]} />;
```

Here's the list of exportable components:

- `<EvaluationsTable />` - `./src/agenthub/components/EvaluationsTable.tsx`
- `<EvaluationsCompare />` - `./src/agenthub/pages/evaluations-compare-drawer.tsx`
- `<EvaluationDetailsDrawer />` - `./src/agenthub/pages/evaluation-details-drawer.tsx`
- `<EvaluatorResult />` - `./src/agenthub/pages/evaluator-result.tsx`
- `<AggregateResultsTable />` - `./src/agenthub/components/AggregateResultsTable.tsx`

## 📄 License

See [LICENSE](LICENSE)

## 📞 Support

For issues and questions, please [open an issue on GitHub](https://github.com/RailtownAI/railtracks-visualizer/issues).