open-index/open-npm huggingface dataset:
npm package: @spec-box/text-parser
Description: ## Установка
Latest version: 0.2.0

# @spec-box/text-parser

## Установка

```sh
npm i -PE @spec-box/text-parser
```

## Использование

```ts
import { parse } from '@spec-box/text-parser';

const text = 'При `нажатии` должен открывать диалог $dialog-name или ссылку https://xyz.com';
const result = parse(text);

// {
//   text: 'При `нажатии` должен открывать диалог $dialog-name или ссылку https://xyz.com',
//   meta: {
//     highlights: [{ raw: '`нажатии`', value: 'нажатии' }],
//     references: [{ raw: '$dialog-name', value: 'dialog-name' }],
//     urls: [{ raw: 'https://xyz.com', value: 'https://xyz.com' }]
//   }
// }
```
npm package: @spec-corpus/corpus
Description: Spec corpus content package — curated engineering specs for AI-assisted development
Latest version: 0.1.2

# @spec-corpus/corpus

`@spec-corpus/corpus` is the content payload package consumed by the `spec-corpus` CLI.

## Purpose

- Contains curated corpus content under `dist/`
- Ships `release-manifest.json` for deterministic integrity checks
- Not intended as a direct end-user command package

## Typical usage

Most users should use the CLI package:

```bash
npx spec-corpus init
```

The CLI resolves and installs this package automatically.
npm package: @spec-kit/cli
Description: Spec-Kit CLI - Setup tool for Spec-Driven Development projects
Latest version: 0.3.1

# @spec-kit/cli

[![npm version](https://badge.fury.io/js/@spec-kit%2Fcli.svg)](https://www.npmjs.com/package/@spec-kit/cli)

Spec-Kit CLI - Setup tool for Spec-Driven Development projects

## Installation

```bash
# Install globally with Bun
bun install -g @spec-kit/cli

# Or use directly with bunx
bunx @spec-kit/cli init my-project
```

## Usage

### Initialize a new project

```bash
# Create a new project directory
specify init my-project

# Initialize in current directory
specify init --here

# Specify AI assistant
specify init my-project --ai claude
specify init my-project --ai gemini
specify init my-project --ai copilot
specify init my-project --ai cursor

# Specify script type
specify init my-project --script sh  # POSIX shell (default on Unix)
specify init my-project --script ps  # PowerShell (default on Windows)

# Skip git initialization
specify init my-project --no-git

# Skip AI tool checks
specify init my-project --ignore-agent-tools
```

### Check installed tools

```bash
specify check
```

## Features

- 🚀 **Cross-platform**: Works on Windows, macOS, and Linux
- 🤖 **AI Assistant Support**: Templates for Claude Code, Gemini CLI, GitHub Copilot, and Cursor
- 📦 **Template System**: Downloads latest templates from GitHub releases
- 🎯 **Interactive Setup**: Arrow-key selection for configuration options
- 🌳 **Progress Tracking**: Tree-based visualization of setup steps
- 🔧 **Tool Detection**: Automatic checking of required tools
- 📜 **Script Variants**: Support for both POSIX shell and PowerShell scripts

## Architecture

The CLI is built with:

- **Bun**: Runtime and package manager
- **TypeScript**: Type-safe development
- **Commander**: CLI framework
- **Inquirer**: Interactive prompts
- **Picocolors**: Terminal colors

## Development

```bash
# Install dependencies
bun install

# Run in development
bun run dev

# Build for production
bun run build

# Run tests
bun test

# Build standalone executables
bun run build:standalone  # Current platform
bun run build:windows     # Windows
bun run build:mac         # macOS
bun run build:linux       # Linux
```

## Migration from Python CLI

This TypeScript implementation replaces the original Python `specify_cli` with:

- Better performance through Bun's native compilation
- Type safety and better IDE support
- Consistent tooling with the rest of the spec-kit ecosystem
- Easier testing and maintenance

### Feature Parity

All features from the Python CLI are preserved:

- ✅ Interactive AI assistant selection
- ✅ Script type selection (sh/ps)
- ✅ Template downloading from GitHub
- ✅ Git repository initialization
- ✅ Progress tracking with tree display
- ✅ Tool availability checking
- ✅ Cross-platform support
- ✅ `--here` flag for current directory initialization

## License

MIT
npm package: @spec-spac/from-openapi
Description: Generate idiomatic spac TypeScript from existing OpenAPI specs
Author: rbby
Latest version: 0.0.2

# @spec-spac/from-openapi

Reverse generator — parse an existing OpenAPI 3.1 spec and emit idiomatic [spac](../spac) TypeScript code.

## Install

```sh
npm install @spec-spac/from-openapi
```

## CLI usage

```sh
# Preview what will be generated (dry-run)
npx spac-from-openapi spec.json

# Generate to a directory
npx spac-from-openapi spec.json --out ./generated

# Strip path prefixes before grouping
npx spac-from-openapi spec.json --out ./generated \
  --strip '/accounts/{account_id}' --strip '/zones/{zone_id}'

# Enable source map support in generated code
npx spac-from-openapi spec.json --out ./generated --debug
```

### Options

| Flag | Description |
|---|---|
| `--out <dir>` | Output directory (omit for dry-run) |
| `--strip <prefix>` | Path prefix to strip before grouping (repeatable) |
| `--name <name>` | Override API title |
| `--spec-version <ver>` | Override OpenAPI version (default: from spec) |
| `--debug` | Emit `debug: true` in Api constructor |

## Programmatic usage

```ts
import { generate } from '@spec-spac/from-openapi'

const result = generate(specJson, {
  stripPrefixes: ['/accounts/{account_id}'],
  debug: true,
})

// result is a map of filename -> generated TypeScript source
for (const [file, source] of Object.entries(result.files)) {
  console.log(file, source.length)
}
```

## Formatter plugins

The generated code can be formatted with either Biome or Prettier via optional adapter packages:

- [`@spec-spac/from-openapi-biome`](./plugins/biome) — Biome formatter
- [`@spec-spac/from-openapi-prettier`](./plugins/prettier) — Prettier formatter

## Related

- [`spac`](../spac) — core DSL library
- [`spac-playground`](../playground) — live viewer for generated specs

## License

MIT
npm package: @spec-this/cli
Description: CLI tool for Spec-This code intelligence platform
Author: Spec-This
Latest version: 1.0.1

# @spec-this/cli

//force update


Official CLI tool for the Spec-This code intelligence platform.

## Debug Mode

The CLI includes comprehensive debug logging to help troubleshoot issues, especially with API calls.

### Enabling Debug Mode

You can enable debug logging in several ways:

**1. Using the `--debug` flag:**
```bash
spec-this scan --debug
```

**2. Using the `--log-level` flag:**
```bash
spec-this scan --log-level debug
```

**3. Using environment variables:**
```bash
export SPEC_THIS_DEBUG=true
spec-this scan
```

Or:
```bash
export SPEC_THIS_LOG_LEVEL=debug
spec-this scan
```

**4. For a single command:**
```bash
SPEC_THIS_DEBUG=true spec-this scan
```

### Log Levels

Available log levels (from most to least verbose):
- `trace` - Very detailed trace information
- `debug` - Detailed debug information (includes all API calls and responses)
- `info` - General informational messages (default)
- `warn` - Warning messages
- `error` - Error messages
- `fatal` - Application crashes

### What Debug Mode Shows

When debug mode is enabled, you'll see:
- Every API request with method, endpoint, URL, and authentication status
- Request body size and preview (for POST/PUT requests)
- Response status, timing, and preview
- Detailed error information including 413 errors with payload size
- Batch splitting information (when scan data is split into batches)
- Scan statistics (file counts, symbol counts, etc.)

### Troubleshooting 413 Errors

If you're getting 413 (Payload Too Large) errors, debug mode will show:
- The exact size of the request that failed
- Whether batching is being used
- How many batches are being sent and their sizes

This information can help determine if the batch size needs to be reduced or if there's an issue with the API server configuration.
npm package: @spec.dev/client
Description: Spec JavaScript client
Author: Spec
Latest version: 0.0.8

# Spec JavaScript Client

The JavaScript client for Spec.

## Installation

```
$ npm install --save @spec.dev/client
```

## Initialization

To create a new client that communicates with your Spec project's API:

```javascript
import { createClient } from '@spec.dev/client'

const specUrl = 'https://your-project-id.spec.dev'
const specKey = 'public-anon-key'

// Create Spec Client.
const spec = createClient(specUrl, specKey)
```

...

## Spec Auth / Wallet Sign-in

Enabling wallet sign-in for your users is as simple as running the following function:

```javascript
const { user, session, isNewUser, error } = await spec.auth.connect()
```

...

The following can be run to sign the current user out of all active sessions.

```javascript
const { error } = await spec.auth.disconnect()
```

## GraphQL

...

```javascript
import { gql } from '@spec.dev/client'

const GET_USER_DID_PAIRS = gql`
    query getUserDidsPairs {
        users {
            id
            did {
                domain
                provider
                email
                url
                avatar
                name
                description
            }
            createdAt
        }
    }
`

const { data, error } = await spec.query(GET_USER_DID_PAIRS)
```

### Services

...

### Calling a service

```javascript
const { data, error } = spec.service('<service-name>').perform(...args)
```

**Example**: Call the create DID service:

```javascript
const { data, error } = spec.service('did.create').perform('0x...')
```

...
npm package: @spec.dev/ecosystem
Description: Spec Ecosystem Client
Author: Spec
Latest version: 0.0.1

# Spec Ecosystem Client

JavaScript client to interface with resources in the Spec ecosystem.

## Requirements

* Node.js >= 16
* npm >= 8

## Installation

```bash
$ npm install @spec.dev/ecosystem
```

## Auth

In order to make changes within your namespace on Spec, you will first need a **namespace access token**. 

It's important to keep this token private — and because of this, any write operations performed by this library should be initiated on the server-side, with your token stored as an environment variable.

## Client

Creating a new instance of the ecosystem client is simple.

```typescript
import { SpecEcosystemClient } from '@spec.dev/ecosystem'

const ecosystem = new SpecEcosystemClient({
    namespaceToken: process.env.SPEC_NAMESPACE_TOKEN
})
```

## Contract Group Operations

Currently, this library can be used:

1. Create new contract groups
2. Add new contracts to an existing group

### Creating contract groups

```javascript
const group = 'namespace.ContractName'
const chainIds = [1, 5, 137, ...] // chain ids for the group
const abi = [{ type: 'event', name: 'Transfer', ... }, ...]

const { ok, error } = await ecosystem.createContractGroup(group, chainIds, abi)
```

### Adding contracts to a group

> [!NOTE]
> The contract group *must exist* before using this method to add contracts to it.

Currently, only a single chain can be used per API call. This may change in the near future, so stay tuned.

```javascript
const group = 'namespace.ContractName'
const chainId = 5
const addresses = ['0x123...', '0x456...']

const { ok, error } = await spec.addContractsToGroup(group, chainId, addresses)
```

## License

MIT
npm package: @spec.dev/query
Description: Spec Query Client
Author: Spec
Latest version: 0.0.2

# Spec Query Client

JavaScript client for querying Spec's shared tables.

## Installation

```bash
$ npm install @spec.dev/query
```

## Quickstart

```typescript
import { SpecQueryClient } from '@spec.dev/query'

// Client to query Spec's shared tables.
const client = new SpecQueryClient({ 
    apiKey: process.env.PROJECT_API_KEY
})

// Basic query for a specific block.
const { data } = await client.query('ethereum.blocks', {
    where: { number: 1000000 }
})

// Streaming query for all lens profiles.
await client.stream('lens.profiles', {}, async batch => {
    // batches of 1000 records.
})
```

## License

MIT
npm package: @spec.dev/spec
Description: Spec
Author: Spec
Latest version: 0.0.31

# Spec

Public docs launching...<br>
<img width="624" alt="Screen Shot 2023-08-10 at 7 08 22 PM" src="https://github.com/spec-dev/spec/assets/6496306/8fb3cd54-a163-493a-977d-fd175c79a671">
npm package: @spec/npm
Description: > NPM-related utilties used in `@spec/cli`
Latest version: 3.0.0-alpha.5

# `@spec/npm`

> NPM-related utilties used in `@spec/cli`

## Getting Started

Run the following command using [npm](https://www.npmjs.com/):

```bash
npm install -S @spec/npm
```

If you prefer [Yarn](https://yarnpkg.com/en/), use the following command instead:

```bash
yarn add @spec/npm
```

## 🤲 Contributing

To learn more about how to contribute, look [here](/.github/CONTRIBUTING.md)!
npm package: @spec2tools/cli
Description: CLI for interacting with OpenAPI-based AI tools
Latest version: 0.2.2

# @spec2tools/cli

CLI for interacting with OpenAPI-based AI tools.

## Installation

```bash
npm install -g @spec2tools/cli
```

Or use directly with npx:

```bash
npx @spec2tools/cli start --spec ./openapi.yaml
```

## Usage

### Set Environment Variables

Define a `.env` file and set the `OPENAI_API_KEY` environment variable:

```
OPENAI_API_KEY=your-api-key
```

### Start the Agent

```bash
# With a remote OpenAPI spec URL
npx @spec2tools/cli start --spec https://api.example.com/openapi.json

# With a local file
npx @spec2tools/cli start --spec ./openapi.yaml

# Skip authentication
npx @spec2tools/cli start --spec ./openapi.yaml --no-auth

# Provide API key directly
npx @spec2tools/cli start --spec ./openapi.yaml --api-key "your-api-key"

# Enable code mode (2 tools: search + execute)
npx @spec2tools/cli start --spec ./openapi.yaml --code-mode
```

### Chat Mode

Once started, you can interact with the AI agent naturally:

```
> What can you do?
I have access to the following tools:
- createUser: Create a new user
- getUser: Retrieve user by ID
- listUsers: List all users

> Create a user named John with email john@example.com
[Calling createUser with {"name":"John","email":"john@example.com"}]
Created user successfully: { id: "123", name: "John", email: "john@example.com" }
```

### Special Commands

```bash
# List available tools
> /tools

# Call a tool directly
> /call createUser --name "John" --email "john@example.com"

# Show tool schema
> /schema createUser

# Clear conversation history
> /clear

# Show help
> /help

# Exit
> /exit
```

## Examples

The `examples/` directory contains sample OpenAPI specifications:

- `sample-api.yaml` - Simple API without authentication
- `authenticated-api.yaml` - API with OAuth2 authentication
- `context7.yaml` - Context7 API with OAuth2 (PKCE + dynamic client registration)

## Supported OpenAPI Features

### Supported
- `GET`, `POST`, `PUT`, `PATCH`, `DELETE` operations
- Path parameters (string, number, boolean)
- Query parameters (string, number, boolean)
- Request body with simple JSON schemas (primitives, flat objects)
- Security schemes: OAuth2 (authorization code with PKCE), API Key, Bearer token
- OAuth2 Dynamic Client Registration (auto-registers client with the auth server)

### Not Supported (throws error)
- Nested objects beyond 1 level
- Arrays of objects
- `anyOf`, `oneOf`, `allOf` schemas
- File uploads
- `$ref` references

## License

MIT
npm package: @spec2tools/sdk
Description: Create AI SDK tools from OpenAPI specifications
Latest version: 0.2.1

# @spec2tools/sdk

Create AI SDK tools from OpenAPI specifications.

## Installation

```bash
npm install @spec2tools/sdk
```

## Usage

```ts
import { createTools } from '@spec2tools/sdk';
import { generateText, stepCountIs } from 'ai';
import { openai } from '@ai-sdk/openai';

const tools = await createTools({ spec: './openapi.yaml' });

const result = await generateText({
  model: openai('gpt-4o'),
  tools,
  prompt: 'List all users',
  stopWhen: stepCountIs(3)
});

console.log(result.text);
```

### Code Mode

Enable code mode to collapse all endpoints into 2 tools (`search` + `execute`), reducing token usage by ~99.9%:

```ts
const tools = await createTools({
  spec: './openapi.yaml',
  codeMode: true,
});
```

### Code Mode for MCP Clients

Use `convertToolsToCodeMode` to apply code mode to tools from any source, such as `createMCPClient` from `@ai-sdk/mcp`:

```ts
import { createMCPClient } from '@ai-sdk/mcp';
import { convertToolsToCodeMode } from '@spec2tools/sdk';
import { generateText, stepCountIs } from 'ai';
import { openai } from '@ai-sdk/openai';

const client = await createMCPClient({
  transport: { type: 'sse', url: 'http://localhost:3000/sse' },
});

try {
  const tools = convertToolsToCodeMode(await client.tools());

  const result = await generateText({
    model: openai('gpt-4o'),
    tools,
    prompt: 'List all users',
    stopWhen: stepCountIs(3),
  });

  console.log(result.text);
} finally {
  await client.close();
}
```

## API

### `createTools(options: Spec2ToolsOptions): Promise<ToolSet>`

Creates AI SDK-compatible tools from an OpenAPI specification.

#### Options

- `spec` (string, required): Path or URL to the OpenAPI specification file (JSON or YAML)
- `codeMode` (boolean, optional): When `true`, returns 2 code-mode tools instead of one per endpoint

#### Returns

A `Promise` that resolves to an object of AI SDK tools.

#### Throws

- `Error` if the API requires authentication (unless `codeMode` is enabled). For authenticated APIs, use the `@spec2tools/cli` package instead.

### `convertToolsToCodeMode(tools: ToolSet): ToolSet`

Converts an existing AI SDK ToolSet into code mode (2 tools: `search` + `execute`). Useful when you have tools from another source (e.g. `createMCPClient` from `@ai-sdk/mcp`) and want to reduce token usage.

## License

MIT
npm package: @spec2tools/sdk-tanstack
Description: Create TanStack AI tools from OpenAPI specifications
Latest version: 0.1.1

# @spec2tools/sdk-tanstack

Create TanStack AI tools from OpenAPI specifications.

## Installation

```bash
npm install @spec2tools/sdk-tanstack @tanstack/ai
```

## Usage

```ts
import { createTools } from '@spec2tools/sdk-tanstack';
import { chat, toServerSentEventsResponse } from '@tanstack/ai';
import { openai } from '@tanstack/ai-openai';

const tools = await createTools({ spec: './openapi.yaml' });

const stream = chat({
  adapter: openai(),
  model: 'gpt-4o',
  messages,
  tools,
});

return toServerSentEventsResponse(stream);
```

### Code Mode

Enable code mode to collapse all endpoints into 2 tools (`search` + `execute`), reducing token usage by ~99.9%:

```ts
const tools = await createTools({
  spec: './openapi.yaml',
  codeMode: true,
});
```

### Converting Existing Tools to Code Mode

Use `convertToolsToCodeMode` to apply code mode to any existing `ServerTool` array:

```ts
import { convertToolsToCodeMode } from '@spec2tools/sdk-tanstack';

const tools = await createTools({ spec: './openapi.yaml' });
const codeModeTools = convertToolsToCodeMode(tools);
```

## API

### `createTools(options: Spec2ToolsOptions): Promise<ServerTool[]>`

Creates TanStack AI server tools from an OpenAPI specification.

#### Options

- `spec` (string, required): Path or URL to the OpenAPI specification file (JSON or YAML)
- `codeMode` (boolean, optional): When `true`, returns 2 code-mode tools instead of one per endpoint

#### Returns

A `Promise` that resolves to an array of TanStack AI `ServerTool` instances, ready to pass to `chat()`.

#### Throws

- `Error` if the API requires authentication (unless `codeMode` is enabled). For authenticated APIs, use the `@spec2tools/cli` package instead.

### `convertToolsToCodeMode(tools: ServerTool[]): ServerTool[]`

Converts an existing TanStack AI `ServerTool` array into code mode (2 tools: `search` + `execute`). Useful when you have tools from another source and want to reduce token usage.

## License

MIT
npm package: @speca11y/cli
Description: CLI for SpecA11y - automated WCAG accessibility checker
Latest version: 0.5.0

# @speca11y/cli

Command-line interface for [SpecA11y](../../README.md) — automated WCAG accessibility checking from the terminal.

## Installation

```bash
pnpm add -g @speca11y/cli
pnpm exec playwright install chromium
```

## Usage

```bash
# Check a URL (default: WCAG AA, text output)
speca11y https://example.com

# Check a local HTML file
speca11y ./page.html

# WCAG AAA level
speca11y https://example.com --level AAA

# JSON output
speca11y https://example.com --format json

# SARIF output to file
speca11y https://example.com --format sarif -o report.sarif

# Include passing rules
speca11y https://example.com --include-passes

# Disable specific rules
speca11y https://example.com --disable-rules color-contrast,img-alt
```

### Semantic Analysis

Enrich reports with LLM-powered quality assessment. Requires an LLM provider SDK and API key.

```bash
# With Anthropic Claude (default provider, uses ANTHROPIC_API_KEY env var)
speca11y https://example.com --semantic --format json

# With OpenAI (uses OPENAI_API_KEY env var)
speca11y https://example.com --semantic --llm-provider openai

# With local Ollama (no API key needed)
speca11y https://example.com --semantic --llm-provider ollama

# Custom model
speca11y https://example.com --semantic --llm-provider openai --llm-model gpt-4o
```

## Options

| Flag | Description | Default |
|------|-------------|---------|
| `-l, --level <A\|AA\|AAA>` | WCAG conformance level | `AA` |
| `-f, --format <text\|json\|sarif>` | Output format | `text` |
| `--include-passes` | Show passing rules | `false` |
| `--disable-rules <ids>` | Comma-separated rule IDs to skip | — |
| `-o, --output <file>` | Write to file instead of stdout | — |
| `--semantic` | Enable LLM-based semantic quality analysis | `false` |
| `--llm-provider <provider>` | LLM provider: `anthropic`, `openai`, or `ollama` | `anthropic` |
| `--llm-model <model>` | Override the provider's default model | — |
| `--llm-api-key <key>` | API key (or set `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` env var) | — |
| `--ollama-url <url>` | Ollama base URL | `http://localhost:11434` |

## Exit Codes

| Code | Meaning |
|------|---------|
| `0` | No violations found |
| `1` | Violations found |
| `2` | Runtime error |

## License

[MIT](../../LICENSE)
npm package: @speca11y/core
Description: Automated WCAG accessibility checker powered by Playwright
Latest version: 0.5.0

# @speca11y/core

Core rule engine for [SpecA11y](../../README.md) — an automated WCAG accessibility checker powered by Playwright. Goes beyond static DOM analysis with interactive checks: keyboard trap detection, focus indicator verification via screenshot diffs, text spacing injection, viewport reflow testing, and real target size measurement.

## Installation

```bash
pnpm add @speca11y/core playwright
pnpm exec playwright install chromium
```

## Usage

```typescript
import { check } from '@speca11y/core';
import { chromium } from 'playwright';

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto('https://example.com');

const report = await check(page, { level: 'AA' });

for (const entry of report.entries) {
  for (const result of entry.results) {
    console.log(`[${result.type}] ${entry.rule.id}: ${result.message}`);
  }
}

await browser.close();
```

## API

### `check(page, config?): Promise<Report>`

Runs all registered rules against a Playwright `Page`.

**Config options:**

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `level` | `'A' \| 'AA' \| 'AAA'` | `'AA'` | WCAG conformance level |
| `versions` | `WcagVersion[]` | `['2.0','2.1','2.2']` | WCAG versions to include |
| `includePasses` | `boolean` | `false` | Include passing results |
| `disableRules` | `string[]` | `undefined` | Rule IDs to skip |
| `enableRules` | `string[]` | `undefined` | Rule IDs to force-enable |
| `ruleTimeout` | `number` | `10000` | Per-rule timeout (ms) |
| `include` | `string[]` | `undefined` | CSS selectors to scope checks to |
| `exclude` | `string[]` | `undefined` | CSS selectors to skip |

### `buildSarifReport(report): SarifLog`

Converts a `Report` into SARIF 2.1.0 format.

### `buildReport(entries, page, duration): Report`

Low-level report builder.

### `registerRule(rule) / getRule(id) / getAllRules() / filterRules(config)`

Rule registry management.

### `createRuleContext(page): RuleContext`

Creates a rule execution context from a Playwright `Page`.

## 113 Built-in Rules

- **48 Perceivable** — image alt text, color contrast, text spacing, reflow, landmarks, tables, lists, orientation, etc.
- **27 Operable** — keyboard traps, focus indicators, target size, skip links, scrollable regions, etc.
- **19 Understandable** — labels, language, error handling, consistent UI, label-content matching, etc.
- **16 Robust** — ARIA attributes, roles, required children/parents, dialog names, field names, etc.
- **3 WCAG 3.0 Draft** — text customization, reduced motion, deceptive patterns

See the [full rule reference](../../docs/rules.md) for all rules with WCAG criteria mappings.

## License

[MIT](../../LICENSE)
npm package: @speca11y/semantic
Description: LLM-powered semantic quality analysis for SpecA11y accessibility reports
Latest version: 0.2.4

# @speca11y/semantic

LLM-powered semantic quality analysis for [SpecA11y](../../README.md) accessibility reports. Enriches heuristic warnings with AI assessments — turning ambiguous flags into actionable verdicts.

## Installation

```bash
pnpm add @speca11y/semantic
```

Install the LLM SDK for your provider of choice:

```bash
# Anthropic Claude
pnpm add @anthropic-ai/sdk

# OpenAI
pnpm add openai

# Ollama — no SDK needed, uses HTTP API
```

## Usage

```typescript
import { check } from '@speca11y/core';
import { enrich } from '@speca11y/semantic';

const report = await check(page, { level: 'AA' });

const enriched = await enrich(report, {
  provider: { provider: 'anthropic' },
  page, // optional — enables element screenshots for vision models
});

for (const entry of enriched.entries) {
  for (const result of entry.results) {
    if (result.semantic) {
      console.log(`${entry.rule.id}: ${result.semantic.verdict} (${result.semantic.confidence})`);
      console.log(`  ${result.semantic.explanation}`);
      if (result.semantic.suggestion) {
        console.log(`  Suggestion: ${result.semantic.suggestion}`);
      }
    }
  }
}
```

## Providers

| Provider | Model (default) | Vision | API Key |
|----------|----------------|--------|---------|
| `anthropic` | `claude-sonnet-4-20250514` | Yes | `ANTHROPIC_API_KEY` |
| `openai` | `gpt-4o-mini` | Yes | `OPENAI_API_KEY` |
| `ollama` | `llama3.2` / `llava` (images) | Yes | None |

```typescript
// Custom model and endpoint
const enriched = await enrich(report, {
  provider: {
    provider: 'ollama',
    model: 'mistral',
    baseUrl: 'http://localhost:11434',
  },
});
```

## Semantic Annotations

Each enriched result gets a `semantic` property:

```typescript
interface SemanticAnnotation {
  verdict: 'good' | 'poor' | 'unclear';
  confidence: number;   // 0–1
  explanation: string;
  suggestion?: string;
  provider: string;
  model: string;
}
```

- **`good`** — the element passes semantic review (e.g., alt text is descriptive)
- **`poor`** — the element has a real accessibility issue
- **`unclear`** — the LLM could not determine quality with confidence

## Targeted Rules

Only warnings from these rules are sent to the LLM:

- `img-alt-quality` — image alt text quality
- `link-name-quality` — link text descriptiveness
- `label-quality` — form label clarity
- `lang-mismatch` — content language consistency
- `button-name` — button label quality
- `document-title` — page title descriptiveness
- `video-caption-quality` — video caption adequacy
- `frame-title` — iframe title quality
- `empty-heading` — heading content presence

## Options

```typescript
interface EnrichOptions {
  provider: ProviderConfig;
  page?: Page;          // Playwright page for screenshots
  rules?: string[];     // Override which rules to enrich
  concurrency?: number; // Max parallel LLM calls (default: 5)
}
```

## License

MIT
npm package: @specbeelabs/drupal-theme-init
Description: A Yeoman generator to scaffold and initialize a Drupal theme.
Author: Sagar
Latest version: 2.2.3

# drupal-theme-init [![NPM version][npm-image]][npm-url]
🚀 Initialize a Drupal theme. 🚀

## Installation

First, install drupal-theme-init using [npm](https://www.npmjs.com/) (we assume you have pre-installed [node.js](https://nodejs.org/)) preferably >=20.

```bash
npm install -g @specbeelabs/drupal-theme-init
```

## Usage

- Type the following command to start the generator. Start this inside the custom theme folder for easier options. 

```
drupal-theme-init
```

- Continue selecting options as per requirement.

## License

MIT © [Specbee](https://specbee.com)

[npm-image]: https://badge.fury.io/js/@specbeelabs%2Fdrupal-theme-init.svg
[npm-url]: https://npmjs.org/package/@specbeelabs/drupal-theme-init
npm package: @specferret/cli
Description: SpecFerret keeps your specs honest.
Latest version: 0.2.0

# @specferret/cli

Spec drift detection CLI for contract-driven teams.

[![npm version](https://img.shields.io/npm/v/@specferret/cli)](https://www.npmjs.com/package/@specferret/cli)
[![license](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)

`@specferret/cli` catches breaking contract drift before merge by scanning markdown contracts, classifying impact, and enforcing safe resolution paths.

## Install

```bash
bun install -g @specferret/cli
```

## Quickstart

```bash
ferret init
ferret lint
```

If drift is detected:

```bash
ferret review
```

## Core commands

```bash
ferret init
ferret scan
ferret lint
ferret extract
ferret review
```

## CI usage

```bash
ferret lint --ci
```

Reusable GitHub Action:

```yaml
- name: SpecFerret CI
	uses: BenGardiner123/action@v1
	with:
		baseline-mode: committed
```

Supports CI baseline modes:

- `--ci-baseline committed` (default)
- `--ci-baseline rebuild`

Starter templates:

- `docs/ci-templates/ferret-action-single-package.yml`
- `docs/ci-templates/ferret-action-monorepo.yml`
- `docs/ci-templates/ferret-action-pr-only.yml`

## Validation status

Sprint 5 branch-matrix validation (spec-kit + BMAD) is green with explicit S40/S41/S42 assertions:

- spec-kit: https://github.com/BenGardiner123/spec-ferret-validation-spec-kit/actions/runs/23962649755
- BMAD: https://github.com/BenGardiner123/specferret-validation-bmad/actions/runs/23962652352

## Runtime requirements

- Bun 1.0+

The CLI is Bun-first and designed for low-latency local and CI runs.

## Links

- Source: https://github.com/BenGardiner123/spec-ferret
- Docs: https://specferret.dev
- Core package: https://www.npmjs.com/package/@specferret/core
npm package: @specferret/core
Description: SpecFerret core engine — spec drift detection.
Latest version: 0.2.0

# @specferret/core

Core engine for SpecFerret contract extraction, validation, graph reconciliation, and drift analysis.

[![npm version](https://img.shields.io/npm/v/@specferret/core)](https://www.npmjs.com/package/@specferret/core)
[![license](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)

## What this package is for

`@specferret/core` is the runtime library behind the CLI. Use it when you want to embed SpecFerret behavior in scripts, custom tooling, or internal workflows.

It includes:

- Store implementations (`sqlite`, `postgres`)
- Frontmatter extraction and schema validation
- Reconciler logic for direct/transitive impact
- Context graph generation utilities

## Install

```bash
npm i @specferret/core
```

## Runtime requirements

- Bun 1.0+

SpecFerret core is Bun-first and uses Bun-compatible runtime behavior.

## Typical consumers

- Internal platform tooling that needs drift checks in-process
- CI wrappers that need machine-readable drift metadata
- Custom developer workflows on top of SpecFerret reconciliation data

## Validation status

Core behavior is validated through the Sprint 5 external branch-matrix harness (spec-kit + BMAD), including explicit assertions for:

- S40 transitive depth thresholds
- S41 review proof artifacts
- S42 extract determinism

Latest green runs:

- spec-kit: https://github.com/BenGardiner123/spec-ferret-validation-spec-kit/actions/runs/23962649755
- BMAD: https://github.com/BenGardiner123/specferret-validation-bmad/actions/runs/23962652352

## Looking for the CLI?

Install `@specferret/cli` if you want the end-user command interface:

```bash
bun install -g @specferret/cli
```

## Links

- Source: https://github.com/BenGardiner123/spec-ferret
- Docs: https://specferret.dev
- CLI package: https://www.npmjs.com/package/@specferret/cli
npm package: @specfocus/view-focus.data.local-storage
Description: Local storage data provider for @specfocus/view-focus
Author: François Zaninotto
Latest version: 0.0.4

# view-focus.local-storage

A dataProvider for [@specfocus/view-focus](https://github.com/marmelab/view-focus) that uses a local database, persisted in localStorage.

The provider issues no HTTP requests, every operation happens locally in the browser. User editions are persisted across refreshes and between sessions. This allows local-first apps, and can be useful in tests.

## Installation

```sh
npm install --save @specfocus/view-focus.data.local-storage
```

## Usage

```jsx
// in src/App.js
import React from 'react';
import { Admin, Resource } from '@specfocus/view-focus/core';
import localStorageDataProvider from '@specfocus/view-focus.data.local-storage';

const dataProvider = localStorageDataProvider();
import { PostList } from './posts';

const App = () => (
    <Admin dataProvider={dataProvider}>
        <Resource name="posts" list={PostList} />
    </Admin>
);

export default App;
```

### defaultData

By default, the data provider starts with no resource. To set default data if the storage is empty, pass a JSON object as the `defaultData` argument:

```js
const dataProvider = localStorageDataProvider({
    defaultData: {
        posts: [
            { id: 0, title: 'Hello, world!' },
            { id: 1, title: 'FooBar' },
        ],
        comments: [
            { id: 0, post_id: 0, author: 'John Doe', body: 'Sensational!' },
            { id: 1, post_id: 0, author: 'Jane Doe', body: 'I agree' },
        ],
    }
});
```

The `defaultData` parameter must be an object literal with one key for each resource type. Values are arrays of resources. Resources must be object literals with at least an `id` key.

Foreign keys are also supported: just name the field `{related_resource_name}_id` and give an existing value.

### loggingEnabled

As this data provider doesn't use the network, you can't debug it using the network tab of your browser developer tools. However, it can log all calls (input and output) in the console, provided you set the `loggingEnabled` parameter:

```js
const dataProvider = localStorageDataProvider({
    loggingEnabled: true
});
```

## Features

This data provider uses [FakeRest](https://github.com/marmelab/FakeRest) under the hood. That means that it offers the same features:

- pagination
- sorting
- filtering by column
- filtering by the `q` full-text search
- filtering numbers and dates greater or less than a value
- embedding related resources

## License

This data provider is licensed under the MIT License, and sponsored by [marmelab](https://marmelab.com).
npm package: @specforge-driven/specforge
Description: Spec-Driven Development Kit by d2railabs
Author: d2railabs
Latest version: 1.0.3

# SpecForge

Spec-Driven Development Kit by **d2railabs** — Define your API with YAML specs, generate production-ready code.

## Features

- **Spec-first workflow**: Define models and endpoints in `.spec.yaml` files
- **Code generation**: Generate models, Prisma schemas, Fastify routes, tests, docs, and middleware
- **Full development lifecycle**: Constitution → Specify → Clarify → Plan → Tasks → Analyze → Implement
- **Diff & Watch**: See what would change before generating, auto-validate on spec changes
- **GitHub integration**: Create issues from generated tasks
- **Claude Code integration**: Auto-configures CLAUDE.md and slash commands on init

## Quick Start

```bash
# Install globally
pnpm add -g specforge

# Create a new project
npx create-specforge my-app
cd my-app

# Or initialize in an existing project
specforge init .

# Define your spec in spec/*.spec.yaml, then:
specforge validate
specforge generate
```

## Commands

| Command | Description |
|---------|-------------|
| `specforge init [name]` | Scaffold a new project or init in existing one |
| `specforge validate` | Validate spec YAML files |
| `specforge generate` | Generate code from specs |
| `specforge constitution` | Create/amend project constitution |
| `specforge specify <name>` | Create a structured feature spec |
| `specforge clarify <spec-id>` | Scan spec for ambiguities |
| `specforge plan <spec-id>` | Generate implementation plan |
| `specforge tasks <spec-id>` | Generate dependency-ordered task list |
| `specforge analyze [spec-id]` | Cross-artifact consistency check |
| `specforge implement <spec-id>` | Run full pipeline (clarify → plan → tasks → analyze → generate) |
| `specforge diff` | Show what generate would change |
| `specforge watch` | Watch specs and auto-validate |
| `specforge issues <spec-id>` | Create GitHub Issues from tasks |
| `specforge remove` | Remove SpecForge from project |

## Spec File Format

```yaml
name: User
tableName: users
fields:
  - name: id
    type: uuid
    primary: true
  - name: email
    type: string
    unique: true
    validations:
      - type: email
  - name: name
    type: string
    validations:
      - type: minLength
        value: 2

endpoints:
  - method: GET
    path: /users
    description: List all users
  - method: POST
    path: /users
    description: Create a new user
    body:
      - field: email
        required: true
      - field: name
        required: true
```

## Generator Plugins

- **model** — TypeScript interfaces and Zod schemas
- **prisma** — Prisma schema models
- **fastify** — Fastify route handlers
- **test** — Vitest test suites
- **docs** — OpenAPI 3.0 spec, Mermaid ER diagrams, API README
- **middleware** — JWT auth, request validation, error handler

## Monorepo Structure

```
packages/
  core/        — Types, validation, spec parsing, planning logic
  cli/         — Commander.js CLI with 15 commands
  generator/   — Handlebars-based code generation with 6 plugins
  create-specforge/ — Project scaffolding (npx create-specforge)
```

## License

ISC
npm package: @specgraph/mcp
Description: MCP server for validating, querying, and editing Spec Graph repositories.
Latest version: 0.5.1

# @specgraph/mcp

Node.js MCP server for Spec Graph repositories.

## Usage

```bash
npx @specgraph/mcp --repo-dir /path/to/repo
```

## Environment variables

- `SPECGRAPH_MCP_SCHEMA_DIR`: load `graph.schema.json` and `node.schema.json` from a local directory.
- `SPECGRAPH_MCP_SCHEMA_BASE_URL`: fetch schemas from an alternate base URL.
- `SPECGRAPH_MCP_CACHE_TTL_MS`: cache TTL for loaded graphs (default: `1500`).
- `SPECGRAPH_MCP_DEFAULT_SPECGRAPH_VERSION`: default graph version for `init_specgraph` (default: `1.0.0`).

## Key query tools

- `get_upstream_context` (alias: `get_affecting_nodes`): all upstream nodes that influence a target node, with reason labels.
- `list_dependencies`: direct `depends_on` dependencies.
- `list_dependencies_full`: transitive dependency closure with normative layer-propagated guidance and informational-only dependency context.
- `get_effective_constraints`: direct + inherited constraining nodes plus transitive layer-originated propagation.
- `get_group_subgraph`: grouping-node (`feature` or `layer`) subgraph traversal.
npm package: @spechero/cli
Description: Command line tool for creating and sharing specs via spechero.io
Author: Ritchie Young
Latest version: 0.0.1

# SpecHero Command Line Utility

Instantly generate and manage quick test projects in a variety of languages.

For instance,
```
spechero new ruby-rspec calc
```
Creates a Ruby project called `calc`, opens it in your editor and runs starts
a Docker container to run your specs as you edit them.

# Install
## Requires:
   - NodeJS 14 or above
   - Docker-Compose (as provided by Docker for Mac or Docker for Windows)

   ```
   npm install spechero -g
   ```
   or

   ```
   yarn global add spechero
   ```

# Usage

Use Spechero to generate and manage scratch projects. Your test projects live (by default) in your `$HOME/.spechero` folder.

Run `spechero help` for usage information.
npm package: @specialblend/apollo-blackbox
Description: React Apollo Providers with loading, error and data states
Author: specialblend
Latest version: 1.0.4

# @specialblend/apollo-blackbox

> React Apollo Providers with loading, error and data states

[![NPM](https://img.shields.io/npm/v/@specialblend/apollo-blackbox.svg)](https://www.npmjs.com/package/@specialblend/apollo-blackbox) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save @specialblend/apollo-blackbox
```

## Usage

```jsx
import React from 'react'
import MyComponent from './MyComponent'
import typeDefs from './typeDefs'

import { ApolloBlackbox } from '@specialblend/apollo-blackbox'

// simulates query is loading forever
function LoadingExample () {
    return (
        <ApolloBlackbox loading>
            <MyComponent />
        </ApolloBlackbox>
    )
}

// simulates query returned an error
function ErrorExample () {

    const error = new Error('oops. something bad happened.')

    return (
        <ApolloBlackbox error={error}>
            <MyComponent />
        </ApolloBlackbox>
    )
}

// simulates mock API from typeDefs
function DataExample () {
    return (
        <ApolloBlackbox typeDefs={typeDefs}>
            <MyComponent />
        </ApolloBlackbox>
    )
}

```

## License

MIT © [specialblend](https://github.com/specialblend)