open-index/open-npm huggingface dataset:
npm package: @judegao/next-agents-md
Description: Generate a documentation index for Claude/Agents files in Next.js projects
Author: Jude Gao
Latest version: 0.0.10

# next-agents-md

Give AI coding agents (Claude, Cursor, etc.) access to Next.js documentation.

## Why?

AI agents work better when they can reference up-to-date documentation instead of relying on training data. This tool downloads the official Next.js docs and creates a compact index that agents can use to look up the right documentation files.

## Usage

Run in your Next.js project:

```bash
npx @judegao/next-agents-md
```

This will:
1. Detect your Next.js version
2. Download matching documentation to `.next-docs/`
3. Inject a docs index into your `CLAUDE.md` (or `AGENTS.md`)

### Non-interactive mode

```bash
# Auto-detect version, output to CLAUDE.md
npx @judegao/next-agents-md --md CLAUDE.md

# Specify version explicitly
npx @judegao/next-agents-md --version 15.1.3 --md CLAUDE.md
```

### Options

| Flag | Description |
|------|-------------|
| `--version <version>` | Next.js version (auto-detected if not provided) |
| `--md <path>` | Target markdown file (default: `CLAUDE.md`) |

## How it works

The tool injects a compressed index between `<!-- NEXT-AGENTS-MD-START -->` and `<!-- NEXT-AGENTS-MD-END -->` markers. This index tells the AI agent where to find documentation files in `.next-docs/`.

When working on Next.js tasks, the agent will read the relevant docs from `.next-docs/` rather than relying on potentially outdated training data.

## License

MIT
npm package: @judegao/next-skills
Description: CLI to install and manage Agent Skills for Claude Code, Gemini CLI, Cursor, and Codex
Latest version: 0.0.11

# next-skills

Next.js Agent Skill Installer

## Supported Agents

- Claude Code / OpenCode
- Gemini CLI
- Antigravity
- Cursor
- Codex

> Note: Some agents may only support skills in their experimental versions (e.g., Gemini CLI, Cursor).

## Usage

To install/update the Next.js Agent Skill, run in your Next.js project:

```bash
npx @judegao/next-skills
```

## License

MIT
npm package: @judgy-ts/anthropic
Description: Anthropic provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/anthropic

Anthropic provider for Judgy TypeScript.

`@judgy-ts/anthropic` implements the `LlmProvider` contract from `@judgy-ts/core` using Anthropic's Messages API, so you can use Claude models as the semantic judge in Judgy evaluations.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/anthropic
```

## What This Package Contains

- `AnthropicProvider`
- `AnthropicProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { AnthropicProvider } from "@judgy-ts/anthropic";

const provider = new AnthropicProvider({
  apiKey: process.env.ANTHROPIC_API_KEY!,
  model: "claude-sonnet-4-20250514"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/azure-openai
Description: Azure OpenAI provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/azure-openai

Azure OpenAI provider for Judgy TypeScript.

`@judgy-ts/azure-openai` implements the `LlmProvider` contract from `@judgy-ts/core` using Azure OpenAI chat completions, so you can evaluate outputs with a deployment you already manage in Azure.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/azure-openai
```

## What This Package Contains

- `AzureOpenAiProvider`
- `AzureOpenAiProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { AzureOpenAiProvider } from "@judgy-ts/azure-openai";

const provider = new AzureOpenAiProvider({
  endpoint: process.env.AZURE_OPENAI_ENDPOINT!,
  apiKey: process.env.AZURE_OPENAI_API_KEY!,
  deploymentName: "gpt-4o"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/core
Description: Portable core contracts and policies for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/core

Core evaluation models, provider contracts, and assertion helpers for Judgy TypeScript.

`@judgy-ts/core` gives you the low-level building blocks for semantic testing of AI and LLM output. It includes the `LlmProvider` contract, the `SemanticEvaluator`, evaluation result models, and assertion policy helpers that higher-level packages build on top of.

## Installation

```bash
npm install @judgy-ts/core
```

## What This Package Contains

- `LlmProvider`, `LlmRequest`, and `LlmResponse` for integrating a judge model
- `SemanticEvaluator` for turning an output and expectation into an evaluation result
- `EvaluationEvidence` and `EvaluationResult` models
- `evaluateSemanticAssertion`, `evaluateScoreAssertion`, and `evaluateDurationAssertion` for pass/fail decisions
- `formatAssertionFailureMessage` for readable failure output

## Usage

```ts
import {
  LlmRequest,
  LlmResponse,
  SemanticEvaluator,
  evaluateSemanticAssertion,
  type LlmProvider
} from "@judgy-ts/core";

class InlineProvider implements LlmProvider {
  async complete(_request: LlmRequest): Promise<LlmResponse> {
    return new LlmResponse({
      text: JSON.stringify({
        confidence: 0.96,
        reasoning: "The answer clearly mentions the refund deadline."
      })
    });
  }
}

const evaluator = new SemanticEvaluator(new InlineProvider());
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);

const decision = evaluateSemanticAssertion(result, { minimumScore: 0.8 });

if (!decision.succeeded) {
  throw new Error("Semantic assertion failed.");
}
```

## Related Packages

- `@judgy-ts/expect` adds higher-level `expect(...)` matchers for Jest and Vitest
- provider packages such as `@judgy-ts/openai`, `@judgy-ts/ollama`, and `@judgy-ts/http` implement `LlmProvider` for common runtimes

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/deepseek
Description: DeepSeek provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/deepseek

DeepSeek provider for Judgy TypeScript.

`@judgy-ts/deepseek` implements the `LlmProvider` contract from `@judgy-ts/core` using DeepSeek chat completions, so you can use DeepSeek models as the semantic judge in Judgy evaluations.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/deepseek
```

## What This Package Contains

- `DeepSeekProvider`
- `DeepSeekProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { DeepSeekProvider } from "@judgy-ts/deepseek";

const provider = new DeepSeekProvider({
  apiKey: process.env.DEEPSEEK_API_KEY!,
  model: "deepseek-chat"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/expect
Description: High-level expect-style testing package for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/expect

High-level `expect(...)` matchers for semantic testing with Judgy TypeScript.

`@judgy-ts/expect` builds on `@judgy-ts/core` and adds matchers for semantic assertions, minimum score checks, and duration checks in Jest-compatible test runners.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/expect expect
```

Install Jest or Vitest in your test project as usual.

## What This Package Contains

- `judgyMatchers`
- matcher contracts used by the Judgy `expect(...)` integration
- support for `toJudgy`, `toHaveJudgyScore`, and `toBeWithinJudgyDuration`

## Usage

```ts
import { expect } from "@jest/globals";
import { judgyMatchers } from "@judgy-ts/expect";

expect.extend(judgyMatchers);

const evaluator = {
  async evaluate() {
    return {
      evidence: {
        confidence: 0.95,
        reasoning: "The answer clearly mentions the refund deadline.",
        evaluatorName: "SemanticEvaluator"
      },
      actualOutput: "You can request a refund within 30 days of purchase.",
      expectation: "The answer should mention the refund deadline.",
      evaluationDurationMs: 120
    };
  }
};

await expect({
  evaluator,
  actualOutput: "You can request a refund within 30 days of purchase.",
  expectation: "The answer should mention the refund deadline."
}).toJudgy({ minimumScore: 0.8 });
```

## Related Packages

- `@judgy-ts/core` provides the evaluator and assertion primitives behind the matchers
- provider packages such as `@judgy-ts/openai`, `@judgy-ts/ollama`, and `@judgy-ts/http` can be used with a real `SemanticEvaluator`

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/google
Description: Google provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/google

Google Gemini provider for Judgy TypeScript.

`@judgy-ts/google` implements the `LlmProvider` contract from `@judgy-ts/core` using the Gemini `generateContent` API, so you can evaluate outputs with Google models in Judgy.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/google
```

## What This Package Contains

- `GoogleProvider`
- `GoogleProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { GoogleProvider } from "@judgy-ts/google";

const provider = new GoogleProvider({
  apiKey: process.env.GOOGLE_API_KEY!,
  model: "gemini-2.5-flash"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/http
Description: Generic HTTP provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/http

Generic HTTP provider for Judgy TypeScript.

`@judgy-ts/http` implements the `LlmProvider` contract from `@judgy-ts/core` for text-producing HTTP endpoints. It is useful when you want Judgy to call a custom gateway, wrapper, or service without writing a provider from scratch.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/http
```

## What This Package Contains

- `HttpProvider`
- `HttpProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { HttpProvider } from "@judgy-ts/http";

const provider = new HttpProvider({
  endpoint: "http://localhost:3000/judge",
  requestTemplate: "{\"prompt\":\"{{prompt}}\"}",
  responseJsonPath: "$.response"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/mistral
Description: Mistral provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/mistral

Mistral provider for Judgy TypeScript.

`@judgy-ts/mistral` implements the `LlmProvider` contract from `@judgy-ts/core` using Mistral chat completions, so you can use Mistral models as the semantic judge in Judgy evaluations.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/mistral
```

## What This Package Contains

- `MistralProvider`
- `MistralProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { MistralProvider } from "@judgy-ts/mistral";

const provider = new MistralProvider({
  apiKey: process.env.MISTRAL_API_KEY!,
  model: "mistral-medium-latest"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/moonshot
Description: Moonshot provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/moonshot

Moonshot provider for Judgy TypeScript.

`@judgy-ts/moonshot` implements the `LlmProvider` contract from `@judgy-ts/core` using Moonshot chat completions, so you can use Kimi models as the semantic judge in Judgy evaluations.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/moonshot
```

## What This Package Contains

- `MoonshotProvider`
- `MoonshotProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { MoonshotProvider } from "@judgy-ts/moonshot";

const provider = new MoonshotProvider({
  apiKey: process.env.MOONSHOT_API_KEY!,
  model: "kimi-k2.5"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/ollama
Description: Ollama provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/ollama

Ollama provider for Judgy TypeScript.

`@judgy-ts/ollama` implements the `LlmProvider` contract from `@judgy-ts/core` for local or hosted Ollama instances, so you can run semantic evaluations without depending on a hosted API key.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/ollama
```

## What This Package Contains

- `OllamaProvider`
- `OllamaProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { OllamaProvider } from "@judgy-ts/ollama";

const provider = new OllamaProvider({
  baseUrl: "http://localhost:11434",
  model: "llama3:8b"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts
npm package: @judgy-ts/openai
Description: OpenAI provider for Judgy TypeScript.
Author: Mauro Gioberti
Latest version: 0.1.2

# @judgy-ts/openai

OpenAI provider for Judgy TypeScript.

`@judgy-ts/openai` implements the `LlmProvider` contract from `@judgy-ts/core` using OpenAI chat completions, so you can use OpenAI models as the semantic judge in Judgy evaluations.

## Installation

```bash
npm install @judgy-ts/core @judgy-ts/openai
```

## What This Package Contains

- `OpenAiProvider`
- `OpenAiProviderOptions`

## Usage

```ts
import { SemanticEvaluator } from "@judgy-ts/core";
import { OpenAiProvider } from "@judgy-ts/openai";

const provider = new OpenAiProvider({
  apiKey: process.env.OPENAI_API_KEY!,
  model: "gpt-4o"
});

const evaluator = new SemanticEvaluator(provider);
const result = await evaluator.evaluate(
  "You can request a refund within 30 days of purchase.",
  "The answer should mention the refund deadline."
);
```

## Related Packages

- `@judgy-ts/core` provides `SemanticEvaluator`, `LlmRequest`, and `LlmProvider`
- `@judgy-ts/expect` adds higher-level `expect(...)` matchers

## Repository

- https://github.com/maurogioberti/judgy-ts