open-index/open-npm huggingface dataset:
npm package: @nobulex/breach
Description: Breach detection and violation reporting for the Nobulex covenant framework
Latest version: 0.2.1

# @nobulex/breach

Breach detection, attestation creation, verification, and trust graph propagation for the Stele protocol.

## TrustGraph Propagation Rules

The `TrustGraph` propagates trust degradation when a breach attestation is processed. Understanding these rules is essential for modeling cascading effects across dependent agents.

### Severity → Trust Status

| Severity | Violator Status |
|----------|-----------------|
| `critical` | `revoked` |
| `high`     | `restricted` |
| `medium`   | `degraded` |
| `low`      | `trusted` (no change) |

### Propagation Path

1. **Violator** receives status from severity (depth 0).
2. **Dependents** are degraded by one level per hop via BFS.
3. **Degradation chain**: `revoked` → `restricted` → `degraded` → (stop).

### Dependency Semantics: `registerDependency(upstreamHash, downstreamHash)`

- **First arg (upstream)**: The agent whose breach *causes* propagation. When this agent breaches, its dependents are affected.
- **Second arg (downstream)**: The agent *affected* when the upstream breaches. Downstream "depends on" upstream.

`registerDependency(B, A)` means: A is a dependent of B. When B breaches, A's trust status is degraded.
Think of it as: "A depends on B" (A relies on B) → `registerDependency(B, A)`.

Example: API consumer A relies on API provider B. Call `graph.registerDependency(B, A)`.
When B breaches, A's status degrades (A was depending on B).

```
B (violator) --breach--> B: revoked
         |
         v
A (dependent) --> A: restricted (one level down from revoked)
         |
         v
C (dependent of A) --> C: degraded (one level down from restricted)
```

### Rules Summary

- **BFS propagation**: All transitive dependents are visited in breadth-first order.
- **Degrade by one**: Each hop applies one step down the chain (revoked→restricted→degraded).
- **Worse wins**: If a node already has a bad status, it is only updated if the new status is worse.
- **Degraded/trusted stop propagation**: Once status is `degraded`, further propagation does not change it (no level below degraded for dependents).

### Usage

```typescript
import { TrustGraph, createBreachAttestation } from '@nobulex/breach';

const graph = new TrustGraph();
graph.registerDependency(violatorHash, dependentHash);

graph.onBreach((event) => {
  console.log(`${event.affectedAgent}: ${event.previousStatus} -> ${event.newStatus} (depth ${event.propagationDepth})`);
});

const attestation = await createBreachAttestation(/* ... */);
const events = await graph.processBreach(attestation);
```
npm package: @nobulex/identity
Description: Identity and DID management for the Nobulex covenant framework
Latest version: 0.2.1

# @nobulex/identity

Agent identity creation, evolution, lineage tracking, and DID management for the Stele covenant framework.

## Evolution Policy and `computeCarryForward`

When an agent's identity evolves (model change, capability change, operator transfer, etc.), reputation may be partially carried forward. The `computeCarryForward` function returns a value in `[0, 1]` indicating what fraction of reputation is preserved.

### Default Policy (`DEFAULT_EVOLUTION_POLICY`)

| Change Type | Rate | Description |
|-------------|------|-------------|
| `created` | 1.0 | New identity; full reputation |
| `model_update` (same family) | 0.80 | Version bump within same model (e.g. claude-3 → claude-3.1) |
| `model_update` (different family) | 0.20 | Provider or model ID change |
| `capability_expansion` | 0.90 | Adding capabilities |
| `capability_reduction` | 1.0 | Removing capabilities (trust-preserving) |
| `operator_transfer` | 0.50 | Operator key change |
| `fork` | 0.50 | Same as operator transfer |
| `merge` | min(0.90, 0.80) | Merging identities |
| `minor_update` (no model/cap changes) | 0.95 | Metadata-only change |
| Unknown | 0.0 | Full rebuild; no carry-forward |

### Usage

```typescript
import { computeCarryForward, evolveIdentity, DEFAULT_EVOLUTION_POLICY } from '@nobulex/identity';

// Check carry-forward before evolving
const rate = computeCarryForward('model_update', currentIdentity, {
  model: { provider: 'anthropic', modelId: 'claude-3', modelVersion: '2.0' },
});
// rate === 0.80 (same family)

// Custom policy
const customPolicy = { ...DEFAULT_EVOLUTION_POLICY, operatorTransfer: 0.75 };
const rate2 = computeCarryForward('operator_transfer', identity, {}, customPolicy);
```

The `reputationCarryForward` value is stored in each lineage entry and used by the reputation layer to decay trust across identity evolutions.
npm package: @nobulex/kova
Description: Open cryptographic protocol (MIT) — the trust layer for the agent economy. AI agents declare behavioral commitments, prove compliance, build verifiable reputation.
Author: Nobulex Labs, Inc.
Latest version: 0.2.1

# Kova

**The trust layer for the agent economy.**

Kova is an open cryptographic protocol (MIT license) that enables AI agents to declare behavioral commitments, prove compliance, and build verifiable reputation across platforms. Single package, one import, 30-minute integration.

## Install

```bash
npm install kova
```

## Quick Start

```typescript
import { withKova } from 'kova';

const server = await withKova(yourMCPServer, 'data-isolation');
```

Three lines of code. Your MCP server is now wrapped with covenant enforcement.

## Presets

| Preset | Description |
|--------|-------------|
| `data-isolation` | Read-only data access, no writes, no network |
| `read-write` | Read/write to data and output, no network |
| `network` | Full network access with PII protection |
| `minimal` | Deny all; audit only |

## Advanced: 3 Primitives

For custom integrations, Kova re-exports the protocol primitives:

- **Identity Binding**: `createIdentity`, `evolveIdentity`
- **Covenant Declaration**: `buildCovenant`, `verifyCovenant`
- **Compliance Proof**: `generateComplianceProof`, `Monitor`

```typescript
import { createIdentity, buildCovenant, generateComplianceProof } from 'kova';
```

## License

MIT
npm package: @nobulex/mcp-server
Description: Nobulex MCP compliance server — covenant rule checking, hash-chained audit logs, and integrity verification for any MCP-compatible agent.
Author: nobulexdev
Latest version: 1.0.0

# @nobulex/mcp-server

Nobulex MCP compliance server — covenant rule checking, hash-chained audit logs, and integrity verification for any MCP-compatible agent.

## Tools

| Tool | Description |
|------|-------------|
| `set_rules` | Set covenant rules using `permit`/`forbid`/`require` syntax |
| `check_action` | Check if an action is allowed or blocked by current rules |
| `get_audit_log` | Return the full hash-chained audit trail |
| `verify_log` | Verify integrity of the audit chain (detect tampering) |

## Rule Syntax

```
forbid delete_user Users cannot be deleted
permit read_data Safe to read
require approval Must get approval first
forbid admin.* All admin actions blocked
forbid * Lockdown mode
```

Rules are evaluated in order — first match wins. Unmatched actions are allowed by default.

## Setup

### Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "nobulex": {
      "command": "npx",
      "args": ["-y", "@nobulex/mcp-server"]
    }
  }
}
```

Config file locations:
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

### Cursor

Add to your Cursor MCP settings:

```json
{
  "mcpServers": {
    "nobulex": {
      "command": "npx",
      "args": ["-y", "@nobulex/mcp-server"]
    }
  }
}
```

### Any MCP Client

The server uses stdio transport. Run it with:

```bash
npx @nobulex/mcp-server
```

## Development

```bash
npm install
npm run build
npm test
```

## License

MIT
npm package: @nobulex/quickstart
Description: Zero-config entry point wrapping identity, covenant-lang, and middleware into a single protect() function.
Latest version: 0.2.1

# @nobulex/quickstart

Zero-config 3-line integration for Nobulex. Define rules, enforce at runtime, verify with tamper-proof logs.

## Install

```bash
npm install @nobulex/quickstart
```

## Usage

```javascript
const { protect } = require('@nobulex/quickstart');
const agent = protect('permit read; forbid transfer where amount > 500; require log_all;');
const result = agent.check({ action: 'transfer', amount: 200 });
```

## Learn more

[nobulex.com](https://nobulex.com)
npm package: @nobulex/reputation
Description: Reputation scoring and trust management for the Nobulex covenant framework
Latest version: 0.2.1

# @nobulex/reputation

Reputation scoring, execution receipts, stakes, and delegation for the Stele protocol.

## Stake-Bound Formula

When `stakeData` is provided to `computeReputationScore`, the `weightedScore` is capped by a **stake bound** that ties trust to collateral:

```
stakeBound = min(1, currentStake + 0.5 * (1 - totalBurned) * historyFactor)
```

Where:

- **currentStake** — The agent's active stake amount (0–1)
- **totalBurned** — Fraction of stake burned due to breaches (0–1)
- **historyFactor** — `min(1, totalExecutions / 100)` — scales with execution history

The final `weightedScore` is clamped: `weightedScore = min(weightedScore, stakeBound)`.

When `stakeData` is omitted, `stakeBound = 1` (no cap). This formula ensures that trust cannot exceed what the agent has at risk (collateralization bound).
npm package: @nobulex/trust-futures
Description: Trust futures market for the Stele protocol. Financial instruments betting on agent trust score trajectories. Insurers hedge policies, enterprises signal confidence, speculators trade. Kova takes 1% of every trade (CME Group model).
Latest version: 0.2.1

# @nobulex/trust-futures

Trust futures market for the Stele protocol. Financial instruments betting on agent trust score trajectories. Insurers hedge policies, enterprises signal confidence, speculators trade. Kova takes 1% of every trade (CME Group model).

## Usage

```typescript
import {
  createAndListFuture,
  executeTrade,
  settleFutureAtExpiry,
  KOVA_TRADE_FEE_RATE,
} from '@nobulex/trust-futures';

// Create a future: bet on agent's trust score reaching 0.9
const future = createAndListFuture(
  'agent-1',
  'trustScore',
  0.9,
  Date.now() + 86400000 * 30, // settlement in 30 days
  100,  // premium
  'holder-initial',
);

// Trade: transfer future to new buyer (Kova takes 1% fee)
const trade = executeTrade(future, 'buyer-speculator', 85);
// trade.kovaFee === 0.85 (1% of 85)

// Settle at expiry when actual trust score is known
const settlement = settleFutureAtExpiry(
  { ...future, holder: trade.buyer },
  0.92,  // actual value (above target → bonus payout)
);
```

## Kova Trade Fee

- **Rate**: 1% (`KOVA_TRADE_FEE_RATE = 0.01`)
- **Applied**: On every secondary-market trade (executeTrade)

## See Also

- [examples/13-trust-futures-flow.ts](../../examples/13-trust-futures-flow.ts) — Full create → trade → settle example
- [@nobulex/derivatives](../derivatives) — createFuture, settleFuture primitives
npm package: @nobuojt/console-ansi
Description: Add special character alias at default console. ex.colorize
Author: NobuoJt
Latest version: 1.1.1

# console-ansi

## 説明

コンソールで色付けなどをできるように特殊文字のエイリアスをまとめた。
module作成・公開のトライアルでもある。

# 参考にしたサイト
https://qiita.com/i-tanaka730/items/c85daa3ee2dcde9bd728
npm package: @nobush/server-only
Description: Version of React's [server-only](https://www.npmjs.com/package/server-only) that doesn't throw an error when used in node runtime. Useful in monorepos where shared packages shouldn't be exposed to client code but are used in both react-server and node run
Latest version: 0.0.1

# server-only

Version of React's [server-only](https://www.npmjs.com/package/server-only) that doesn't throw an error when used in node runtime. Useful in monorepos where shared packages shouldn't be exposed to client code but are used in both react-server and node runtimes.
npm package: @nobuti/lingoda
Description: i18n minimal library
Author: nobuti
Latest version: 1.0.2

# Lingoda

Uber small i18n library for general purpose


## Features

- Zero dependencies
- 344 bytes gzziped
- Simple api


## Install

```
npm install @nobuti/lingoda --save
```

## Usage

```
import lingoda from '@nobuti/lingoda'

const locales = {
    en: {
        hello: "Hello, {name}",
        footer: {
            tagline: "Made with ❤️ by nobuti"
        }
    },
    es: {
        hello: "Hola, {name}",
        footer: {
            tagline: "Hecho con ❤️ por nobuti"
        }
    }
}

// initialized
const {t, lang, set} = lingoda(locales, 'en')

// change languaje
lang('es')

// get the current languaje
lang()

// add new locale dynamically
set('fr', {
  hello: "Bonjour, {name}",
  footer: {
    tagline: "Fabriqué avec ❤️ par nobuti"
  }
})

// Using translations
t('hello', {name: 'nobuti'}); // 'Hello, nobuti'
t('footer.tagline'); // 'Made with ❤️ by nobuti'

lang('es')

t('hello', {name: 'nobuti'}); // 'Hola, nobuti'
t('footer.tagline'); // 'Hecho con ❤️ por nobuti'

// Not found translations show the key by default
t('wadus.bogus'); // 'wadus.bogus'
```