open-index/open-npm huggingface dataset:
npm package: @modelize/transfer
Description: Mini ETL.
Author: bemit
Latest version: 0.0.3

# Modelize Transfer

```shell
npm i --save @modelize/transfer
```

## Execution Flow

Start a new transfer with basic options: `new Transfer().start()`

1. `onBefore()`: returns `resumeInfo`
2. *do process:*
    1. `onLoad()`: consumes `resumeInfo` and reduces raw-rows
    2. for each loaded `raw-row`:
        1. `onFilter()`: consumes `raw-row`, return `false` to exclude row
        2. `transform()`: consumes `raw-row` must produce `write-row`
            - filtered/transformed `raw-row` is cleaned directly from internal memory
    3. `beforeWrite()`: consumes `write-rows`, may change the `resumeInfo`
        - must be run before `writing`, as the already written rows are cleaned directly from internal memory
    4. for each `batch-to-write`
        1. `onWrite()`: consumes batch of `write-row`
3. repeat process if `resumeInfo` not `undefined` now
npm package: @modelkit/bridge
Description: Agent adapter bridge for the ModelKit framework. Connects LLM agents to the ModelKit Hub with workspace isolation and runtime launchers.
Latest version: 0.2.1

# @modelkit/bridge

Agent adapter bridge for the ModelKit framework. Connects LLM agents to the ModelKit Hub with workspace isolation and runtime launchers.

## Install

```bash
npm install @modelkit/bridge @modelkit/core
```

## Usage

```typescript
import { createBridge } from '@modelkit/bridge';
import { ClaudeCodeRuntime } from '@modelkit/bridge';
import { ModelKitAdapter } from '@modelkit/bridge';

const bridge = createBridge({
  adapter: new ModelKitAdapter({ hubUrl: 'http://localhost:3000' }),
  runtime: new ClaudeCodeRuntime(),
  agentDir: './agents',
  instructionsDir: './instructions',
});
```

## What's Included

- **Bridge** — Main orchestrator for agent-hub communication
- **Adapters** — ModelKit Hub polling and Agent-to-Agent protocol adapters
- **Runtimes** — Claude Code CLI and generic subprocess launchers
- **Formatters** — START_PACKAGE formatter and DONE_PACKAGE parser
- **Workspace** — Ephemeral task workspace setup and cleanup

## License

MIT
npm package: @modelkit/core
Description: Protocol schemas, enums, models, and parsers for the ModelKit framework.
Latest version: 0.1.0

# @modelkit/core

Protocol schemas, enums, models, and parsers for the ModelKit framework.

## Install

```bash
npm install @modelkit/core
```

## Usage

```typescript
import {
  TaskState,
  RegisterPackageSchema,
  parseBlockFormat,
  parseJsonFormat,
  canTransition,
} from '@modelkit/core';

// Validate a protocol message
const register = RegisterPackageSchema.parse(data);

// Check task state transitions
canTransition(TaskState.QUEUED, TaskState.ASSIGNED); // true

// Parse block-format messages
const parsed = parseBlockFormat(blockString);
```

## What's Included

- **Schemas** — Zod schemas for all protocol messages (Register, Start, Done, Status, Report, Signal, etc.)
- **Enums** — TaskState, ExitReason, SignalType, Operation, Priority
- **Models** — Task, Session, Objective, Agent interfaces with state machine helpers
- **Parsers** — Block-format and JSON-format message deserialization

## License

MIT
npm package: @modelkit/hub
Description: Central orchestration hub for the ModelKit framework. Manages agent registration, task routing, state lifecycle, real-time events, and workflow execution.
Latest version: 0.3.1

# @modelkit/hub

Central orchestration hub for the ModelKit framework. Manages agent registration, task routing, state lifecycle, real-time events, and workflow execution.

## Install

```bash
npm install @modelkit/hub @modelkit/core
```

## Usage

```typescript
import { createModelKitHub } from '@modelkit/hub';

const hub = createModelKitHub({ dbPath: './modelkit.db' });

// Register an agent
hub.registerAgent({ agentId: 'agent-1', capabilities: ['code-review'] });

// Create and route tasks
hub.createTask({ capability: 'code-review', input: '...' });
```

### Framework Adapters

```typescript
// Express
import { createExpressRouter } from '@modelkit/hub/express';
app.use('/api/hub', createExpressRouter(hub));

// Next.js
import { createNextHandlers } from '@modelkit/hub/nextjs';
export const { GET, POST } = createNextHandlers(hub);

// React
import { ModelKitHubProvider, useModelKitTasks } from '@modelkit/hub/react';
```

## What's Included

- **Hub** — Core orchestration with SQLite persistence
- **Routing** — Capability matching and round-robin task assignment
- **Lifecycle** — Task, session, objective, and agent health management
- **Realtime** — WebSocket event broadcasting
- **Workflows** — Multi-step workflow engine with YAML definitions
- **MCP** — Model Context Protocol server and tools
- **Adapters** — Express and Next.js route factories
- **React** — Hooks for tasks, agents, sessions, objectives, workflows

## License

MIT
npm package: @modelkit/instructions
Description: CLI tool and template library for scaffolding ModelKit instruction files.
Latest version: 0.1.0

# @modelkit/instructions

CLI tool and template library for scaffolding ModelKit instruction files.

## Install

```bash
npm install @modelkit/instructions
```

## CLI Usage

```bash
# Scaffold a full instruction directory
npx modelkit-instructions init --dir ./modelkit

# Add a new capability
npx modelkit-instructions add-capability code-review
```

## Programmatic Usage

```typescript
import {
  getConstitution,
  getBootstrapPrompt,
  getHandler,
  getHandlerNames,
  renderConstitution,
} from '@modelkit/instructions';

const constitution = renderConstitution({
  hubUrl: 'http://localhost:3000',
  sessionId: 'session-1',
});
```

## What's Included

- **CLI** — `modelkit-instructions init` and `modelkit-instructions add-capability` commands
- **Templates** — Constitution, bootstrap prompt, handler, capability, and manifest templates
- **API** — Functions for loading and rendering templates programmatically

## License

MIT
npm package: @modelkit/skpkg
Description: Share Claude Code skills, commands, and agents via GitHub Gists
Latest version: 1.0.0

# skpkg

Share Claude Code skills, commands, and agents with others via GitHub Gists.

## What it does

`skpkg` bundles your local Claude Code customizations (skills, commands, and agents from `~/.claude/`) into GitHub Gists. Share a simple `@user/type` identifier with others so they can install your items with one command.

## Prerequisites

- Node.js >= 18
- [GitHub CLI](https://cli.github.com/) installed and authenticated (`gh auth login`)

## Usage

### Push

```sh
npx skpkg push [--name skills|commands|agents] [--select] [--public]
```

Scans `~/.claude/` for items and publishes them as a GitHub Gist.

- `--name` — limit to a specific type (skills, commands, or agents)
- `--select` — cherry-pick individual items to include
- `--public` — create a public gist (default: secret)

### Pull

```sh
npx skpkg pull <@user/type | gist-id>
```

Installs shared items into your `~/.claude/` directory. Accepts an `@user/type` identifier or a raw gist ID.

### Status

```sh
npx skpkg status
```

Checks installed items against their remote gists and reports which have updates available.

### Update

```sh
npx skpkg update [identifier] [--all]
```

Re-pulls the latest version of installed items.

- Pass a specific `@user/type` to update one source
- Use `--all` to update everything

### List

```sh
npx skpkg list
```

Shows all published and installed items with their gist IDs and timestamps.

### Delete

```sh
npx skpkg delete [gist-id] [--name skills|commands|agents]
```

Deletes a shared gist. Use `--name` to delete your published gist by type, or pass a gist ID directly.

## Identifiers

The `@user/type` format (e.g. `@tviles/skills`) resolves to a user's published gist for that type. This is the recommended way to share and install items.

## Supported item types

| Type     | Location                             |
|----------|--------------------------------------|
| Skills   | `~/.claude/skills/<name>/SKILL.md`   |
| Commands | `~/.claude/commands/<name>.md`       |
| Agents   | `~/.claude/agents/<name>.md`         |

Items must have valid YAML frontmatter with `name` and/or `description` fields to be detected.

## License

MIT
npm package: @modelmap/excel-formula-tokenizer
Description: Tokenize Excel formulas
Author: Atsushi Nagase
Latest version: 2.3.2

# excel-formula-tokenizer

Tokenize Excel formulas.

This is E. W. Bachtal's excel formula tokenizer from http://ewbi.blogs.com/develops/2004/12/excel_formula_p.html

## Install

`npm install excel-formula-tokenizer -S`

or

`yarn add excel-formula-tokenizer`

## Usage

```js
const {tokenize} = require('excel-formula-tokenizer');

const tokens = tokenize('SUM(1, 2)');

tokens.forEach({value, type, subtype} => {
  console.log(`value:   ${value}`);
  console.log(`type:    ${type}`);
  console.log(`subtype: ${subtype}`);
  console.log();
});
```

### API

#### tokenize(formula, options)

- formula - string, excel formula
- options - optional object
    - options.language - Language that the formula is in: `'en-US'` or `'de-DE'`

## License

MIT
npm package: @modelrocket/redux-cognito
Description: Redux Cognito
Latest version: 0.0.9

# Redux Cognito Component

Redux Cognito Component

## Installing

```
$ npm install -s @modelrocket/redux-cognito
```
## Usage

#### In your Store configuration for Redux.  The following lines of code will get you up and running

```
import { createStore, applyMiddleware, combineReducers } from 'redux';

// The CognitoReducer uses promiseMiddleware so you must use it
import promiseMiddleware from 'redux-promise';

import { CognitoAPI, CognitoReducer } from '@modelrocket/redux-cognito';

// You must initialize the User Pool with the UserPoolId and ClientId respectively
CognitoAPI.initializeUserPool('us-east-1_XXXXXXXXX', 'XXXXXXgt7urrp75jbcoa1rklqm' );

const appReducer = combineReducers({
  cognito: CognitoReducer.reducer,
  yourOtherReducers,
});

// Optional, for safe measure, delete all the Redux state on logout action.
const rootReducer = (state, action) => {
  if (action.type === CognitoReducer.LOGOUT_USER) {
    return appReducer({}, action);
  }
  return appReducer(state, action);
};

const middleware = composeEnhancers(applyMiddleware(promiseMiddleware));

export const store = createStore(rootReducer, middleware);

```

#### Login Screens

In your login screen workflow we suggest having a Main Login Container that presents the necessary forms.

The main login container will need to Connect to the redux store and be able to dispatch the following actions

```

class Login extends Component {

  ... // Render and Lifecycle methods...

}

const mapStateToProps = (state) => {
  return {
    authError: Store.getAuthError(state),
    resetState: state.cognito.resetState, // This indicates in the password reset workflow, what state you are in
    username: state.cognito && state.cognito.username,
  };
};

const mapDispatchToProps = (dispatch) => {
  return {
    onSubmit: (username, password) => {
      return dispatch(CognitoReducer.authUser(username, password))
        .then((result) => {
          console.log('Result of Login ...', result);
          initializeAPIs(result.payload.accessToken.jwtToken); // Or whatever action you need to do with the JWT Token
        });
    },
    onResetPassword: (username, tempPassword, newPassword) => {
      dispatch(CognitoReducer.newPasswordChallenge(username, tempPassword, newPassword));
    },
    signUp: () => {
      dispatch(NavigationActions.navigate({ routeName: 'SignUp' }));
    },
    forgotPasswordSubmit: (username) => {
      dispatch(CognitoReducer.forgotPassword(username));
    },
    confirmPasswordSubmit: (userName, accessCode, password) => {
      dispatch(CognitoReducer.confirmPassword(userName, accessCode, password));
      dispatch(CognitoReducer.logoutUser());
    },
    resetAuthError: () => {
      dispatch(CognitoReducer.logoutUser());
    },
  };
};

export default connect(mapStateToProps, mapDispatchToProps)(Login);

```

#### To test the package before publish

```
$ npm pack
$ cd `project directory`
$ npm install -s ~/go/src/github.com/ModelRocket/modelrocket-redux-cognito-0.0.x.tgz

```
npm package: @modelrunner/client
Description: The modelrunner.ai client for JavaScript and TypeScript
Latest version: 1.0.8

# modelrunner.ai JavaScript/TypeScript client library

<!-- ![modelrunner npm package](https://img.shields.io/npm/v/modelrunner?color=%237527D7&label=%40modelrunner%2Fclient&style=flat-square) -->

## Introduction

The `modelrunner.ai` JavaScript Client Library provides a seamless way to interact with `modelrunner` endpoints from your JavaScript or TypeScript applications. With built-in support for various platforms, it ensures consistent behavior across web, Node.js, and React Native environments.

## Getting started

Before diving into the client-specific features, ensure you've set up your credentials:

```ts
import { modelrunner } from "@modelrunner/client";

modelrunner.config({
  // Can also be auto-configured using environment variables:
  credentials: "MODELRUNNER_KEY",
});
```

**Note:** Ensure you've reviewed the [modelrunner.ai getting started guide](https://docs.modelrunner.ai) to acquire your credentials and register your functions. Also, make sure your credentials are always protected. See the [../proxy](../proxy) package for a secure way to use the client in client-side applications.

## Long-running functions with `modelrunner.subscribe`

The `modelrunner.subscribe` method offers a powerful way to rely on the [queue system](https://docs.modelrunner.ai/clients/js-client#call-a-model) to execute long-running functions. It returns the result once it's done like any other async function, so your don't have to deal with queue status updates yourself. However, it does support queue events, in case you want to listen and react to them:

```ts
const result = await modelrunner.subscribe("my-function-id", {
  input: { foo: "bar" },
  onQueueUpdate(update) {
    if (update.status === "IN_QUEUE") {
      console.log(`Your position in the queue is ${update.position}`);
    }
  },
});
```

## More features

The client library offers a plethora of features designed to simplify your journey with `modelrunner.ai`. Dive into the [official documentation](https://docs.modelrunner.ai) for a comprehensive guide.
npm package: @modelrunner/server-proxy
Description: The modelrunner.ai server proxy adapter for JavaScript and TypeScript Web frameworks
Latest version: 1.0.1

# modelrunner.ai proxy library

![@modelrunner/server-proxy npm package](https://img.shields.io/npm/v/@modelrunner/server-proxy?color=%237527D7&label=%40modelrunner%2Fserver-proxy&style=flat-square)

## Introduction

The `@modelrunner/server-proxy` library enables you to route client requests through your own server, therefore safeguarding sensitive credentials. With built-in support for popular frameworks like Next.js and Express, setting up the proxy becomes a breeze.

### Install the proxy library:

```
npm install --save @modelrunner/server-proxy
```

## Next.js page router integration

For Next.js applications using the page router:

1. Create an API route in your Next.js app, as a convention we suggest using `pages/api/modelrunner/proxy.js` (or `.ts` if you're using TypeScript):
2. Re-export the proxy handler from the library as the default export:
   ```ts
   export { handler as default } from "@modelrunner/server-proxy/nextjs";
   ```
3. Ensure you've set the `MODELRUNNER_KEY` as an environment variable in your server, containing a valid API Key.

## Next.js app router integration

For Next.js applications using the app router:

1. Create an API route in your Next.js app, as a convention we suggest using `app/api/modelrunner/proxy/route.js` (or `.ts` if you're using TypeScript):
2. Re-export the proxy handler from the library as the default export:

   ```ts
   import { route } from "@modelrunner/server-proxy/nextjs";

   export const { GET, POST, PUT } = route;
   ```

3. Ensure you've set the `MODELRUNNER_KEY` as an environment variable in your server, containing a valid API Key.

## Express integration

For Express applications:

1. Make sure your app supports JSON payloads, either by using `express.json()` (recommended) or `body-parser`:
   ```ts
   app.use(express.json());
   ```
2. Add the proxy route and its handler. Note that if your client lives outside of the express app (i.e. the express app is solely used as an external API for other clients), you will need to allow CORS on the proxy route:

   ```ts
   import * as modelrunnerProxy from "@modelrunner/server-proxy/express";

   app.all(
     modelrunnerProxy.route, // '/api/modelrunner/proxy' or you can use your own
     cors(), // if external clients will use the proxy
     modelrunnerProxy.handler,
   );
   ```

3. Ensure you've set the `MODELRUNNER_KEY` as an environment variable in your server, containing a valid API Key.

## Client configuration

Once you've set up the proxy, you can configure the client to use it:

```ts
import { modelrunner } from "@modelrunner/client";

modelrunner.config({
  proxyUrl: "/api/modelrunner/proxy", // or https://my.app.com/api/modelrunner/proxy
});
```

Now all your client calls will route through your server proxy, so your credentials are protected.

## More information

For a deeper dive into the proxy library and its capabilities, explore the [official documentation](https://modelrunner.ai/docs).
npm package: @modelschedules/timeline
Description: @modelschedules/timeline
Author: datamit
Latest version: 3.2.0

@modelschedules/timeline

#Install

```bash
pnpm add @modelschedules/timeline
```

#Quick start

1. Extend Your Schedule From Pre-defined Models

```ts
import { ParentScheduleModel, ScheduleListModel, ScheduleModel } from '@modelschedules/timeline';

class MyScheduleItem extends ScheduleModel{
    /// ... fields
}

```

2. Import table component

```ts
<script setup lang="ts">
import { ScheduleTimeline } from '@modelschedules/timeline'

const schedules = [
  {
    Id: 1,
    Name: 'Development',
    Description: 'Development Description',
    Schedules: [
      {
        Id: 11,
        Name: 'Planning',
        Description: 'Planning phase',
        StartDate: new Date('2026-01-05'),
        EndDate: new Date('2026-01-20'),
      },
      {
        Id: 12,
        Name: 'Implementation',
        Description: 'Implementation phase',
        StartDate: new Date('2026-01-21'),
        EndDate: new Date('2026-02-10'),
      },
    ],
  },
]

function onOpenScheduleItem(item: any) {
  console.log('Open schedule item:', item)
}
</script>

<template>
  <ScheduleTimeline
    title="Delivery Roadmap"
    :schedules="schedules"
    @openScheduleItem="onOpenScheduleItem"
  />
</template>
```
Documentation

ScheduleTimeline component is project managment chart for visualizing Your schedule items.
Pre defined Model are ScheduleListModel used to extend Your custom models.
Title parameter is name of schedule, with scheduleTheme options you can change look of your components.
Main event is openScheduleItem in corelation with right tool.

License
MIT
npm package: @modeltables/fontawesome-vuetify
Description: @modeltables/fontawesome-vuetify
Author: datamit
Latest version: 4.3.1

@modeltables/fontawesome-vuetify

#Install

```bash
pnpm add @modeltables/fontawesome-vuetify
```

#Quick start

1. Create Header and DataItem Model

```ts
export const header: HeaderModel[] = [
  {
    title: 'Name'
  },
  { 
    title: 'Description'
  }
];

export class ExampleModel {
  Id: number = 0; 
  Name?: string;
  Description?: string;
}
```

2. Import table component

```ts
<Table 
  v-if="dataItems.length"
  :options="{
    Key: 'Id',
    Active: true,
    ShowKey: false
  }"
  :dataheader="dataheader" 
  :showFilters="true"
  :loading="loading"  
  :dataItems="dataItems"
  :crud="false"
  @load="load($event)"
  @search="search($event)"
  @rowClick="rowClick($event)">
```

Documentation

Options data input key are required with optional attributes.

The table shows your data and lets you manage it easily. It has built-in load and search events for quick requests and updates.

Loading spinner appears while items and pagination changes.

Data items are organized in selections with two main events itemSelection and multiSelection to easy control your items.

Using showFilters are essential with rowClick event when paginationModel mode is on for quick data changes.

CRUD features like add, edit, or delete are ready to use.

License MIT