open-index/open-npm huggingface dataset:
npm package: @speajus/diblob-mcp
Description: Model Context Protocol (MCP) server implementation for diblob dependency injection containers
Author: Justin Spears
Latest version: 1.0.3

# @speajus/diblob-mcp

Model Context Protocol (MCP) server implementation for diblob dependency injection containers.

## Overview

`@speajus/diblob-mcp` provides an MCP server that exposes diblob container functionality through the Model Context Protocol, enabling AI assistants and other MCP clients to interact with your dependency injection containers.

## Features

- **MCP Server**: Expose diblob containers through the Model Context Protocol
- **Container Introspection**: Query registered blobs and their dependencies
- **Dynamic Registration**: Register and unregister blobs through MCP tools
- **Type-Safe**: Full TypeScript support with type inference
- **Diblob Architecture**: Follows diblob patterns with separate interface/implementation files

## Installation

```bash
npm install @speajus/diblob-mcp @speajus/diblob @modelcontextprotocol/sdk
```

Requirements: Node.js >= 22.0.0

## Quick Start

```typescript
import { createContainer } from '@speajus/diblob';
import { registerMcpBlobs, mcpServer } from '@speajus/diblob-mcp';

// Create a diblob container
const container = createContainer();

// Register MCP server blobs
registerMcpBlobs(container);

// Start the MCP server by resolving the mcpServer blob.
// The registration uses lifecycle hooks to call server.start() for you.
await container.resolve(mcpServer);
```

## Architecture

Following diblob conventions, this package separates:

- **Interface/Blob Definitions** (`src/blobs.ts`): Type definitions and blob declarations
- **Implementations** (`src/server.ts`): Concrete MCP server implementation
- **Registration** (`src/register.ts`): Registration function that accepts a container

## API Reference

### `registerMcpBlobs(container)`

Registers all MCP-related blobs with the provided container.

```typescript
import { createContainer } from '@speajus/diblob';
import { registerMcpBlobs, mcpServer } from '@speajus/diblob-mcp';

// Start the MCP server (lifecycle hooks will call start() for you)
await container.resolve(mcpServer);

## Lifecycle

The `registerMcpBlobs` helper registers the `mcpServer` blob as a
`Lifecycle.Singleton` with lifecycle hooks:

- `initialize: 'start'` – called the first time the blob is resolved
- `dispose: 'stop'` – called when the blob is invalidated (for example, when
  it or one of its dependencies is re-registered or unregistered)

This means:

- The MCP server starts automatically the first time you resolve `mcpServer`,
  e.g. with `await container.resolve(mcpServer)`.
- The MCP server is stopped automatically when its registration (or its
  dependencies) are invalidated, following diblob's cascading disposal
  semantics.

const container = createContainer();
registerMcpBlobs(container);
```

## License

MIT
npm package: @speajus/diblob-svelte
Description: Svelte integration helpers for diblob dependency injection containers
Author: Justin Spears
Latest version: 1.0.3

# @speajus/diblob-svelte

Svelte 5 integration helpers for [diblob](https://github.com/speajus/diblob).

This package provides small utilities to make it easy to use a diblob
`Container` in a Svelte application:

- `provideContainerContext(container)` – store a diblob container in Svelte
  context from a top-level component.
- `useContainer()` – access the current container from within a component.
- `useBlob(blob)` – resolve a blob from the current container.
- `attachContainerDisposal(container)` – dispose the container when the
  component owning it is destroyed.

These helpers are designed to follow existing diblob patterns (blob
registration functions, explicit container lifetimes) while fitting into the
Svelte 5 component model.
npm package: @speajus/diblob-telemetry
Description: OpenTelemetry integration for diblob containers
Author: Justin Spears
Latest version: 1.0.3

# @speajus/diblob-telemetry

OpenTelemetry instrumentation for diblob containers.

## Quick start

```ts
import { createContainer } from '@speajus/diblob';
import { registerTelemetryBlobs, telemetryContext } from '@speajus/diblob-telemetry';

const container = createContainer();

registerTelemetryBlobs(container, {
  serviceName: 'example',
  exporter: 'console',
  traceSampleRatio: 1.0,
});

await container.resolve(telemetryContext);
```

## Configuration

`registerTelemetryBlobs` accepts a `TelemetryConfig` object with these fields:

- `serviceName` / `serviceVersion`
- `deploymentEnvironment`
- `exporter`: `'otlp-http' | 'console' | 'none'` (default `console`)
- `exporterEndpoint` (used when `exporter` is `otlp-http`)
- `traceSampleRatio` (defaults to `1.0`)
- `enableTraces` / `enableMetrics` / `enablePaths`

You can build this object by hand from environment variables:

```ts
import { createContainer } from '@speajus/diblob';
import {
  registerTelemetryBlobs,
  type TelemetryConfig,
} from '@speajus/diblob-telemetry';

const container = createContainer();

const telemetryConfig: TelemetryConfig = {
  serviceName: process.env.SERVICE_NAME ?? 'example',
  deploymentEnvironment: process.env.NODE_ENV ?? 'development',
  exporter: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ? 'otlp-http' : 'console',
  exporterEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
  traceSampleRatio: Number(process.env.OTEL_TRACE_SAMPLE_RATIO ?? '1.0'),
};

registerTelemetryBlobs(container, telemetryConfig);
```

Or you can drive it from a typed, validated configuration using
[`@speajus/diblob-config`](../../docs/diblob/config.md).