open-index/open-npm huggingface dataset:
npm package: @korora-tech/dhd
Description: DHD - Dial Home Device - Configuration management framework
Latest version: 0.1.0

# DHD - Declarative Host Deployment

A TypeScript-based declarative configuration management system for automating system setup and maintenance.

## Overview

DHD provides a modular, declarative approach to system configuration using a DAG (Directed Acyclic Graph) based execution model. It supports various action types including file management, package installation, command execution, and HTTP requests.

## Features

- **Declarative Configuration**: Define your system state using TypeScript modules
- **DAG-based Execution**: Automatic dependency resolution and parallel execution
- **Multiple Action Types**:
  - File operations (create, symlink, template)
  - Package management (system packages)
  - Command execution
  - HTTP requests
  - Conditional execution
- **Interactive Visualization**: Built-in Ink-based TUI for monitoring execution
- **Telemetry**: OpenTelemetry integration for observability

## Installation

```bash
bun install
```

## Usage

```bash
# Run with a specific module
bun run cli.ts path/to/module.ts

# Run with visualization
bun run cli.ts --visualize path/to/module.ts
```

## Module Structure

Modules are TypeScript files that export a configuration object:

```typescript
import { defineModule } from './core/module-builder';

export default defineModule({
  name: 'example-module',
  actions: [
    {
      type: 'package',
      name: 'install-git',
      packages: ['git']
    },
    {
      type: 'file',
      name: 'create-config',
      path: '~/.gitconfig',
      content: '[user]\n  name = Your Name'
    }
  ]
});
```

## Architecture

- **Core**: The execution engine, DAG management, and action definitions
- **Actions**: Different action types (command, file, package, http, conditional)
- **Ink**: Interactive terminal UI components
- **Utils**: Helper utilities for system operations

## Development

```bash
# Run tests
bun test

# Publish package
bun run publish
```
npm package: @korostelevm/doc-types
Description: Shared Type Definitions
Latest version: 1.0.1

# @korostelevm/doc-types

**Version:** 1.0.1  
**Description:** Shared Type Definitions

@korostelevm/doc-types provides a robust collection of TypeScript interfaces that define document schemas utilized by the assistant project. These type definitions ensure consistency across your projects by providing a set of strong, validated, and up-to-date data models.

## How It Works

The TypeScript interfaces in this package are generated from Zod schemas through an automated pipeline process:
1. **Zod Schema** - The starting point that defines the validation rules and structure.
2. **JSON Schema** - An intermediate format that provides a standardized way to describe the shape of JSON data.
3. **TypeScript Interfaces** - Final TypeScript definitions generated using `json-schema-to-typescript` to ensure type safety in your code.

## Installation

Install the package via npm:
```bash
npm install @korostelevm/doc-types
```

## Usage

To take advantage of these predefined types, simply import them into your TypeScript projects. Below are examples showcasing how to import and utilize these types:

### Example: Importing the `ARAgingReportSchema`

```typescript
import { ARAgingReportSchema } from '@korostelevm/doc-types';

// Function to process an AR Aging Report
function processARAgingReport(report: ARAgingReportSchema) {
    console.log(`Report Date: ${report.report_date}`);
    console.log(`Total Receivables: ${report.total_receivables}`);
    report.customers.forEach(customer => {
        console.log(`Customer Name: ${customer.customer_name}`);
        console.log(`Total Outstanding: ${customer.total_outstanding}`);
    });
}
```

### Example: Using the `BalanceSheetSchema`

```typescript
import { BalanceSheetSchema } from '@korostelevm/doc-types';

// Function to evaluate a balance sheet
function evaluateBalanceSheet(balanceSheet: BalanceSheetSchema) {
    const totalAssets = balanceSheet.assets.total;
    const totalLiabilities = balanceSheet.liabilities.total;
    console.log(`Total Assets: ${totalAssets}, Total Liabilities: ${totalLiabilities}`);
    console.log(`Equity: ${balanceSheet.equity}`);
}
```

## Benefits

- **Consistency:** Ensures that your data structures align with those used in the main project, reducing errors.
- **Maintainability:** Regular updates keep your types in sync with any schema changes, facilitating seamless project advancement.
- **Validation:** Utilize strong typing facilitated by Zod's validation processes, ensuring your data stays robust and consistent.

By integrating these type definitions into your workspace, you enhance the reliability and clarity of your TypeScript applications, making them easier to maintain and evolve alongside your project's growth.

---

For more documentation and updates, keep an eye on the repository and follow best practices for TypeScript development when utilizing these types in your projects.
npm package: @korprotocol_2/core-sdk
Description: ## Prerequisites
Latest version: 0.1.0-alpha-1

# KOR Protocol SDK

## Prerequisites

To follow this tutorial, ensure you have Node version 20 or later and npm version 8 or higher installed in your environment. You can download the latest LTS (Long Term Support) version from the Node.js official website.

### Create a React/Next Project

First, create a react project using the below guide:

https://react.dev/learn/start-a-new-react-project

### Install the Dependencies

While in the kor-ts-example folder, install the Kor Protocol SDK node package,

You can use any of the following package managers to install the dependencies:

`npm install --save @korprotocol_2/core-sdk`

or

`yarn add @korprotocol_2/core-sdk`

or

`pnpm add @korprotocol_2/core-sdk`

### SDK Initialization

To initialize the SDK, you need to provide your API key and the RPC URL of the blockchain network.

```
import { initKorSDK } from '@korprotocol_2/core-sdk';
const apiKey = 'your-api-key';
const rpcUrl = 'https://your-rpc-url';
const origin  = 'sandbox-origin-url'
const korSDK = initKorSDK(apiKey, {rpcUrl, chain, origin});
```

- API Key: Your unique identifier used to authenticate requests to the KOR Protocol backend. To obtain an API key, please reach out to the admin.
- RPC URL: This is the URL of the blockchain network you are connecting to. It could be the URL of a public or private Ethereum node.
- Chain: This is the id of the chain on which operations should be performed.
- Origin: Initializes the module in a sandbox/production environment. For sandbox environment use https://dq9c2zl6kih9v.cloudfront.net/kor-sdk-api

### [Developer Documentation](https://docs.korprotocol.io/sdk-reference)
npm package: @korpusovmax/material-vue
Description: UI components for each your new project, made according to m3 guidelines.
Author: Korpusov Maxim
Latest version: 1.0.54

# Material Vue
UI components for each your new project, made according to m3 guidelines.

## Installation
You can install **Material Vue** from NPM:
```shell
npm install @korpusovmax/material-vue
```

## Setup project
After installation all you need to fast 
start is to add some lines to your `index.js` in vue project.

```js
import { createApp } from 'vue'
import './style.css'
import App from './App.vue'
// import lib
import MaterialVue from '@korpusovmax/material-vue'
// import styles
import "@korpusovmax/material-vue/style.css"

const app = createApp(App)
// use as plugin
app.use(MaterialVue)

app.mount('#app')
```