open-index/open-npm huggingface dataset:
npm package: @partiellkorrekt/baseproject
Description: Config-files for my base-project
Author: Abraham Przewodnik
Latest version: 1.0.0

# baseproject

Config-files for my base-project

# Usage

Install the module with all peer dependencies

```
yarn add -D @partiellkorrekt/baseproject eslint @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint-config-prettier eslint-plugin-prettier prettier typescript
```

In your package.json add:

```json
{
  "eslintConfig": {
    "extends": "./node_modules/@partiellkorrekt/baseproject/eslint"
  },
  "prettier": {
    "extends": "@partiellkorrekt/baseproject/prettier"
  },
  "babel": {
    "extends": "@partiellkorrekt/baseproject/babel"
  },
  "browserslist": ["defaults", "IE 11"]
}
```

Add a tsconfig.json like this:

```json
{
  "extends": "@partiellkorrekt/baseproject/ts/config"
}
```
npm package: @partisiablockchain/snap
Description: Snap used for Partisia Blockchain.
Latest version: 0.3.0

# Partisia Blockchain snap

Snap used with Partisia Blockchain.

## How do I use the snap

Are you a dapp developer and end-user you should visit
the [Partisia Blockchain documentation](https://partisiablockchain.gitlab.io/documentation/smart-contracts/integration/metamask-snap-integration.html).
npm package: @partitura/sdk
Description: SDK for building Partitura plugins — MCP tool servers, WebView stages, settings panels, and manifest types
Latest version: 2.0.0

# @partitura/sdk

SDK for building [Partitura](https://www.partitura-ai.com) plugins.

## Install

```bash
npm install @partitura/sdk
```

## Three Entry Points

### 1. MCP Tool Servers (server-side)

Build custom tools that AI agents can use:

```typescript
import { createMCPServer, defineTools, PluginContext } from '@partitura/sdk';

const ctx = new PluginContext();
const server = createMCPServer({ name: 'my-tools' });

defineTools(server, {
  my_tool: {
    description: 'Does something useful',
    bubbleText: '{agent} using my tool',
    inputSchema: {
      type: 'object',
      properties: {
        input: { type: 'string', description: 'The input' },
      },
      required: ['input'],
    },
    execute: async ({ input }) => {
      const apiKey = await ctx.getConfig('api_key');
      // ... your logic
      return { content: [{ type: 'text', text: `Result: ${input}` }] };
    },
  },
});

server.start();
```

### 2. WebView Stages (client-side)

Communicate with Partitura from stage HTML:

```html
<script type="module">
  import { createStage } from '@partitura/sdk/stage';

  const stage = createStage();

  // Receive messages from agents
  stage.onMessage((msg) => {
    console.log('Agent says:', msg.text);
  });

  // Send messages to the active agent
  document.getElementById('btn').onclick = () => {
    stage.sendToAgent('Hello from the stage!');
  };
</script>
```

### 3. Extended API (client-side, v2)

For view replacements and rich plugin WebViews:

```typescript
// Agent management
const agents = await Partitura.api.agents.list();
await Partitura.api.agents.deliverPrompt('maestro', 'Start the task');

// UI control
Partitura.api.ui.toast('Done!', 'success');

// Config
const value = await Partitura.api.config.get('api_key');

// Generic backend proxy
const res = await Partitura.api.fetch('/management/agents');
```

## Type-Safe Plugin Manifests

```typescript
import type { PluginManifest } from '@partitura/sdk/types';

const manifest: PluginManifest = {
  apiVersion: 'partitura.dev/v1',
  kind: 'Plugin',
  metadata: {
    name: 'my-plugin',
    version: '1.0.0',
    displayName: 'My Plugin',
    description: 'Does cool things',
  },
  contributions: {
    mcpPackages: [{
      id: 'my-tools',
      name: 'My Tools',
      transport: 'stdio',
      command: 'node',
      args: ['mcp-servers/index.js'],
    }],
  },
};
```

## All 38 Contribution Types

See the [Plugin Documentation](https://www.partitura-ai.com/docs/plugins) for the full manifest reference.

## License

MIT
npm package: @partivo/tcp-proxy
Description: Simple TCP Proxy - Node.js
Author: Partivo
Latest version: 2.0.0

<h1 align="center">@partivo/tcp-proxy</h1>
It is a simple tcp proxy written in NodeJS. You can support development. If there is a problem, you can open Issues.

## Example Code
```js
var proxy = new tcpProxy('127.0.0.1:8888', {
	listen: '127.0.0.1:8887'
});

proxy.on('access', (data) => console.info(data));
proxy.on('error', (data) => console.error(data));
```

## Coming Soon
* IPv6 Support
* Load Blancer
* CLI (Added but still in the test phase)
npm package: @partivo/template-engine
Description: Simple Template Engine - Node.js
Author: Partivo
Latest version: 3.1.0

<h1 align="center">@partivo/template-engine</h1>
Simple Template Engine - Node.js

## Example Code
JavaScript File
```js
import templateEngine from '@partivo/template-engine';
const page = templateEngine.renderFile('/usr/local/bin/template/404.html', {
  hostname: "partivo.net"
}); // 404.html
```

HTML File
```html
<html>
    <head>
        <title>404 Not Found</title>
    </head>
    <body>
        <center><h1>404 Not Found</h1></center>
        <hr>
        <center>{{ hostname }}</center>
    </body>
</html>
```