open-index/open-npm huggingface dataset:
npm package: @peacepiece-compatibility/nuxt-module
Description: Nuxt module for PrimeVue
Author: PrimeTek Informatics
Latest version: 4.3.14

![@primevue/nuxt-module](https://github.com/primefaces/primevue-nuxt-module/assets/11868120/c35e1180-573f-4650-bbe9-0c79bff71f05)

# PrimeVue Nuxt Module

[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]
[![Discord Chat][discord-src]](discord-href)
[![License][license-src]][license-href]

- [✨ Release Notes](https://github.com/primefaces/primevue/packages/nuxt-module/blob/main/CHANGELOG.md#changelog)
- [📖 Documentation](https://primevue.org/nuxt/)

## Quick Setup

1. Add `@primevue/nuxt-module` dependency to your project

```bash
npx nuxi@latest module add primevue
```

2. Add `@primevue/nuxt-module` to the `modules` section of `nuxt.config.{ts,js}`

```js
{
    modules: ['@primevue/nuxt-module'];
}
```

That's it! You can now use `@primevue/nuxt-module` in your Nuxt app ✨

[npm-version-src]: https://img.shields.io/npm/v/@primevue/nuxt-module/latest.svg?color
[npm-version-href]: https://npmjs.com/package/@primevue/nuxt-module
[npm-downloads-src]: https://img.shields.io/npm/dm/@primevue/nuxt-module
[npm-downloads-href]: https://npmjs.com/package/@primevue/nuxt-module
[discord-src]: https://img.shields.io/discord/557940238991753223.svg?colorB=7289da&label=chat&logo=discord
[license-src]: https://img.shields.io/npm/l/@primevue/nuxt-module.svg?style=flat&colorB=yellow
[license-href]: https://npmjs.com/package/@primevue/nuxt-module
npm package: @peacepiece-compatibility/primevue
Description: PrimeVue is an open source UI library for Vue featuring a rich set of 80+ components, a theme designer, various theme alternatives such as Material, Bootstrap, Tailwind, premium templates and professional support. In addition, it integrates with PrimeBloc
Author: PrimeTek Informatics
Latest version: 4.3.12

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![npm version](https://badge.fury.io/js/primevue.svg)](https://badge.fury.io/js/primevue)
[![Discord Chat](https://img.shields.io/discord/557940238991753223.svg?color=7289da&label=chat&logo=discord)](https://discord.gg/gzKFYnpmCY)
[![Prime Discussions](https://img.shields.io/github/discussions-search?query=org%3Aprimefaces&logo=github&label=Prime%20Discussions&link=https%3A%2F%2Fgithub.com%2Forgs%2Fprimefaces%2Fdiscussions)](https://github.com/orgs/primefaces/discussions)

[![PrimeVue Hero](https://www.primefaces.org/static/social/primevue-preview.jpg)](https://primevue.org/)

# PrimeVue Website

PrimeVue is a rich set of open source UI Components for Vue. Visit the [PrimeVue website](https://primevue.org/) for interactive demos, comprehensive documentation and additional resources.
npm package: @peacethinking/conflict-framework
Description: Open standard for AI-assisted conflict resolution — structured taxonomy, scoring, and data models
Latest version: 0.1.0

# @peacethinking/conflict-framework

> Structured conflict taxonomy for AI-assisted mediation systems.

The foundation layer for building conflict resolution tools. Provides the 6-dimension analysis framework, scoring weights, domain types, and Zod validation schemas.

## Install

```bash
npm install @peacethinking/conflict-framework
```

## Usage

### 6-Dimension Framework

```ts
import { DEFAULT_DIMENSIONS, DEFAULT_SCORING_WEIGHTS } from '@peacethinking/conflict-framework';

// 6 dimensions: Situation, Impact, Needs, Causes, Solutions, Boundaries
console.log(DEFAULT_DIMENSIONS);

// 6 scoring weights: factual, logical, coherence, emotional, accountability, constructiveness
console.log(DEFAULT_SCORING_WEIGHTS);
```

### Validate LLM Output

```ts
import { VerdictSchema } from '@peacethinking/conflict-framework/schemas';

const result = VerdictSchema.safeParse(llmOutput);
if (!result.success) {
  console.error('Invalid verdict:', result.error.issues);
}
```

### Extend the Framework

```ts
import { createDimensionRegistry } from '@peacethinking/conflict-framework';

const registry = createDimensionRegistry();
registry.add({
  key: 'dimension-power-dynamics',
  label: 'Power Dynamics',
  description: 'Power imbalances between the parties',
  optional: true,
});
```

### Domain Enums

```ts
import {
  DialogueStatus,
  VerdictOutcomeType,
  WorkflowElementType,
  ParticipantRole,
} from '@peacethinking/conflict-framework';
```

### Types

```ts
import type { Verdict, VerdictRequest, Participant, Vote } from '@peacethinking/conflict-framework';
```

## API

### Dimensions

| Export | Description |
|---|---|
| `DEFAULT_DIMENSIONS` | 6 conflict analysis dimensions |
| `DEFAULT_SCORING_WEIGHTS` | 6 scoring weight factors (sum = 1.0) |
| `SCORING_DIMENSIONS` | Dimension key strings |
| `createDimensionRegistry()` | Create an extensible dimension set |

### Schemas (from `/schemas`)

| Export | Description |
|---|---|
| `VerdictSchema` | Validates full verdict output (scores sum to 100, all dimensions present) |
| `VerdictRequestSchema` | Validates verdict input |
| `DimensionScoresSchema` | Validates per-dimension scores |
| `PerspectiveAnalysisSchema` | Validates perspective analysis output |

### Types

`Verdict`, `VerdictReasoningData`, `VerdictRequest`, `DimensionScores`, `Participant`, `Viewpoint`, `Vote`, `ProposalOption`, `ProposalSet`, `VoteSession`

### Enums

`DialogueStatus`, `DialogueStage`, `ParticipantRole`, `ParticipantStatus`, `VerdictOutcomeType`, `VoteDecision`, `ProposalSource`, `ConflictResolutionMethod`, `WorkflowMode`, `WorkflowElementType`, `NotificationType`, `VerdictTone`

## License

MIT
npm package: @peacethinking/llm-eval
Description: Benchmark any LLM on conflict resolution — the MMLU for PeaceTech
Latest version: 0.1.0

# @peacethinking/llm-eval

> Benchmark any LLM on conflict resolution tasks. The MMLU for PeaceTech.

A deterministic evaluation framework that scores LLM responses on structured conflict resolution tasks. No AI is used in scoring — all evaluation is pure schema validation + heuristics.

## Install

```bash
npm install @peacethinking/llm-eval
```

## CLI Usage

```bash
# Benchmark a single model
npx peaceeval --provider openai --model gpt-4o

# Compare two models
npx peaceeval --compare openai:gpt-4o anthropic:claude-sonnet-4-5-20250929

# Filter by category
npx peaceeval --provider openai --model gpt-4o --category workplace

# Filter by difficulty
npx peaceeval --provider openai --model gpt-4o --difficulty hard

# Output JSON
npx peaceeval --provider openai --model gpt-4o --output results.json
```

## Programmatic Usage

```ts
import { benchmark, compare, createOpenAIProvider } from '@peacethinking/llm-eval';

// Benchmark a model
const results = await benchmark(
  createOpenAIProvider({ model: 'gpt-4o' }),
  { category: 'workplace', difficulty: 'medium' }
);

console.log(results.summary);
// { avgScore: 78.5, schemaCompliance: 95, fairness: 72, ... }
```

```ts
// Compare two models
const comparison = await compare([
  createOpenAIProvider({ model: 'gpt-4o' }),
  createAnthropicProvider({ model: 'claude-sonnet-4-5-20250929' }),
]);

console.log(comparison.leaderboard);
```

## Scoring Dimensions

| Dimension | Weight | What it measures |
|---|---|---|
| **Schema Compliance** | 25% | Valid JSON, matches Zod VerdictSchema |
| **Score Plausibility** | 20% | Scores sum to 100, dimensions have variation, confidence is reasonable |
| **Reframing Quality** | 20% | Substantive what-if scenarios, perspective shifts, bridge message |
| **Fairness** | 20% | Balanced verdicts for ambiguous cases, outcome matches scores |
| **Language Compliance** | 15% | Response is in the requested language |

## Test Scenarios

20 anonymized scenarios across:

- **5 categories**: workplace, family, neighbor, rental, partnership
- **3 difficulties**: easy, medium, hard
- **3 languages**: English, German, Turkish

## Providers

Built-in adapters for:

| Provider | Factory | Env Variable |
|---|---|---|
| OpenAI | `createOpenAIProvider()` | `OPENAI_API_KEY` |
| Anthropic | `createAnthropicProvider()` | `ANTHROPIC_API_KEY` |
| Google | `createGoogleProvider()` | `GOOGLE_API_KEY` |
| Ollama | `createOllamaProvider()` | (local, no key) |

### Custom Provider

```ts
import type { LLMProvider } from '@peacethinking/llm-eval';

const myProvider: LLMProvider = {
  name: 'my-provider',
  async complete(messages, options) {
    // Your implementation
    return { text: '...', latencyMs: 123 };
  },
};
```

## License

MIT
npm package: @peacethinking/mediation-prompts
Description: Production-tested prompt templates for AI-assisted conflict resolution and mediation
Latest version: 0.1.0

# @peacethinking/mediation-prompts

> Production-tested prompt templates for AI-assisted conflict resolution.

Parameterized TypeScript functions that generate structured system/user message pairs for LLM-based mediation. Each prompt includes a Zod output schema for runtime validation.

## Install

```bash
npm install @peacethinking/mediation-prompts
```

## Usage

### Generate a Verdict Prompt

```ts
import { buildVerdictPrompt, VerdictOutputSchema } from '@peacethinking/mediation-prompts';

const { system, user } = buildVerdictPrompt({
  viewpoint1: "My manager assigns me more work than my colleagues...",
  viewpoint2: "The project had tight deadlines and tasks were assigned by availability...",
  languageCode: 'en',
  tone: 'neutral',
});

// Send to any LLM
const response = await llm.chat([
  { role: 'system', content: system },
  { role: 'user', content: user },
]);

// Validate output
const result = VerdictOutputSchema.safeParse(JSON.parse(response));
```

### Analyze a Single Perspective

```ts
import { buildPerspectivePrompt } from '@peacethinking/mediation-prompts';

const { system, user } = buildPerspectivePrompt({
  viewpoint: "I've been feeling overwhelmed since the reorganization...",
  languageCode: 'de',
});
```

### Synthesize Two Viewpoints

```ts
import { buildMediationPrompt } from '@peacethinking/mediation-prompts';

const { system, user } = buildMediationPrompt({
  viewpoint1: "...",
  viewpoint2: "...",
  languageCode: 'en',
});
// Output: { summary, solution_proposals: string[] }
```

### Generate Clarification Questions

```ts
import { buildClarificationPrompt } from '@peacethinking/mediation-prompts';

const { system, user } = buildClarificationPrompt({
  viewpoint: "...",
  languageCode: 'en',
});
```

## API

| Function | Output | Description |
|---|---|---|
| `buildVerdictPrompt()` | Scores, outcome, reframing | Full 6-dimension verdict with scoring |
| `buildPerspectivePrompt()` | Per-dimension analysis | Single viewpoint analysis |
| `buildMediationPrompt()` | Summary + 3-5 proposals | Two-viewpoint synthesis |
| `buildClarificationPrompt()` | 5-dimension questions | Follow-up clarification |

Each function returns `{ system: string, user: string }` and exports a corresponding `*OutputSchema` for Zod validation.

## License

MIT
npm package: @peachai/agent-widget
Description: Embeddable Peach Agent Widget
Latest version: 1.0.5

# Peach Agent Widget

Embeddable agent widget for the Peach platform.

## Install

### CDN
```html
<script src="https://cdn.jsdelivr.net/npm/@peachai/agent-widget/dist/peach-agent-widget.umd.js"></script>
```

### NPM
```bash
npm install @peachai/agent-widget
```

## Use

### Script tag
```html
<script src="/dist/peach-agent-widget.umd.js"
        data-peach-widget
        data-token="YOUR_TOKEN"
        data-mode="both"
        data-base-url="https://your-peach-host">
</script>
```

### Programmatic
```js
import { PeachAgentWidget } from '@peachai/agent-widget'

const widget = new PeachAgentWidget({ token: 'YOUR_TOKEN', baseUrl: 'https://your-peach-host' })
widget.show()
```

## Dev
```bash
npm i
npm run build
npm run serve:examples
```

Open:
- http://localhost:3001/basic.html
- http://localhost:3001/advanced.html
- http://localhost:3001/programmatic.html