open-index/open-npm huggingface dataset:
npm package: @pathmode/cli
Description: The Intent Layer CLI — Spec-Driven Development with Pathmode
Author: Pathmode
Latest version: 2.0.0

# IntentSpec Validation Action

The official GitHub Action for [IntentSpec](https://intentspec.org) — the open standard for Spec-Driven Development.

Use this action to enforce **Functional Guardrails** in your CI/CD pipeline. It validates that your `intent.md` exists and adheres to the [IntentSpec Schema](https://intentspec.org/schema.json).

## Usage

Add this to your workflow file (e.g., `.github/workflows/intentspec.yml`):

```yaml
name: Validate IntentSpec

on: [push, pull_request]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Validate Intent Spec
        uses: JanneL/validate-intentspec-action@v1
        with:
          file: 'intent.md' # Optional (default: intent.md)
```

## Inputs

| Input | Description | Default | Required |
| :--- | :--- | :--- | :--- |
| `file` | Path to the intent markdown file | `intent.md` | No |

## Why use this?

1.  **Prevent Drift:** Ensure AI agents (and humans) have a clear definition of "Done".
2.  **Enforce Structure:** Validate that `objective`, `outcomes`, and `constraints` are defined.
3.  **Governance:** Make IntentSpecs a required part of your PR process.
npm package: @pathors/n8n-nodes-pathors
Description: n8n community node for Pathors - AI voice agent platform
Author: Cerana Studio
Latest version: 0.1.2

# n8n-nodes-pathors

This is an n8n community node for integrating with [Pathors](https://pathors.com) - an AI voice agent platform.

[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

## Installation

Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

## Operations

### Call

- **Create** - Create an outbound call from your configured phone number to a target recipient

## Credentials

To use this node, you need:

- **API Key** - Your Pathors API key

You can obtain this from your [Pathors Dashboard](https://app.pathors.com).

## Usage

1. Add the Pathors node to your workflow
2. Configure your Pathors API credentials
3. Select the resource and operation
4. Fill in the required parameters

### Create Call Example

| Parameter | Description |
|-----------|-------------|
| Project ID | Your Pathors project ID |
| From Number | Your configured phone number with active outbound SIP status (e.g., +14155551234) |
| To Number | Destination phone number in E.164 format (e.g., +14155555678) |
| Dynamic Variables | Optional JSON object for call flow personalization |

## Resources

- [Pathors Documentation](https://docs.pathors.com)
- [Pathors API Reference](https://docs.pathors.com/en/api-reference)
- [n8n Community Nodes Documentation](https://docs.n8n.io/integrations/community-nodes/)

## License

[MIT](LICENSE)
npm package: @paths.design/caws-mcp-server
Description: CAWS Model Context Protocol server for AI agent integration
Author: @darianrosebrook
Latest version: 2.0.0

**Author**: @darianrosebrook

**Status**: Stable, with Structured Logging

---

## Architecture

The MCP server uses a modular handler pattern. The original monolithic `index.js` (2976 SLOC) has been decomposed into a smaller core (`index.js`, 1421 SLOC) plus extracted modules:

```
src/
  index.js                        — Core server setup, transport, and request routing
  tool-definitions.js             — 24 MCP tool JSON Schema definitions
  handlers/
    quality-gates.js              — Quality gate execution, status, and exceptions handlers
    slash-commands.js             — Slash command routing and specs CRUD handlers
```

Handlers are registered via an install function pattern:

```javascript
const { installQualityGatesHandlers } = require('./handlers/quality-gates.js');
const { installSlashCommandHandlers } = require('./handlers/slash-commands.js');

// In server setup:
installQualityGatesHandlers(server);
installSlashCommandHandlers(server);
```

Each handler module exports a single `install*Handlers(server)` function that registers its tool implementations on the shared server instance. Tool JSON Schema definitions live in `tool-definitions.js` and are referenced by the core `index.js` when responding to `ListTools` requests.

---

## Structured Logging

The MCP server now uses **pino** for high-performance structured logging:

### Configuration

Set log level via environment variable:

```bash
# Development (default: debug)
export CAWS_LOG_LEVEL=debug

# Production (default: info)
export NODE_ENV=production
export CAWS_LOG_LEVEL=info

# Force JSON output (useful for log aggregation)
export CAWS_LOG_JSON=true
```

### Log Levels

- **error**: Errors and exceptions
- **warn**: Warning conditions
- **info**: Important events (default in production)
- **debug**: Detailed debugging information (default in development)

### Log Format

**Development** (pretty-printed):

```
[2025-10-10 15:30:00] INFO: MCP client initialized - ready for requests
```

**Production** (JSON for log aggregation):

```json
{
  "level": "info",
  "time": "2025-10-10T15:30:00.000Z",
  "msg": "MCP client initialized - ready for requests"
}
```

### Contextual Logging

The logger adds structured context to all messages:

```javascript
// Component-specific logger
this.logger = createChildLogger({ component: 'CawsMonitor' });

// Structured data in logs
this.logger.info({ specId: 'PROV-0001' }, 'Loaded working spec');

// Error logging with context
this.logger.error({ err: error, file: filePath }, 'Error handling file change');
```

### Benefits

- **Structured data**: Easy to parse and aggregate
- **Performance**: Minimal overhead (asynchronous logging)
- **Configurable**: JSON output for log aggregation
- **Development-friendly**: Pretty output with colors
- **Contextual**: Rich metadata in every log
- **Standards-compliant**: Follows best practices

---

For more information, see `docs/MONITORING.md`
npm package: @paths.design/caws-types
Description: TypeScript type definitions for CAWS (Coding Agent Workflow System)
Author: @darianrosebrook
Latest version: 1.0.0

# @paths.design/caws-types

TypeScript type definitions for CAWS (Coding Agent Workflow System).

## Installation

```bash
npm install @paths.design/caws-types
```

## Usage

```typescript
import {
  WorkingSpec,
  CAWSValidationResult,
  CAWSPolicy,
  BudgetCompliance,
} from '@paths.design/caws-types';

// Type-safe working spec
const spec: WorkingSpec = {
  id: 'FEAT-001',
  title: 'Add user authentication',
  risk_tier: 2,
  mode: 'feature',
  // ... rest of spec
};

// Type-safe validation result
const result: CAWSValidationResult = {
  passed: true,
  verdict: 'pass',
  cawsVersion: '3.4.0',
  timestamp: new Date().toISOString(),
  budgetCompliance: {
    /* ... */
  },
  qualityGates: [],
  waivers: [],
};
```

## Exported Types

### Working Spec Types

- `WorkingSpec` - Complete CAWS working specification
- `AcceptanceCriterion` - Given-When-Then acceptance criteria
- `ContractDefinition` - API contract definitions
- `CAWSConfig` - CAWS configuration from package.json

### Validation Types

- `CAWSValidationResult` - Complete validation result
- `BudgetCompliance` - Budget check results
- `QualityGateResult` - Individual gate results
- `WaiverApplication` - Applied waiver details
- `SpecValidationResult` - Spec structure validation
- `ValidationError` - Validation error details
- `ValidationWarning` - Validation warnings
- `AutoFix` - Auto-fix suggestions

### Policy Types

- `CAWSPolicy` - Complete policy configuration
- `RiskTierConfiguration` - Tier-specific settings
- `PolicyEditRules` - Policy governance rules
- `WaiverApprovalPolicy` - Waiver approval requirements
- `TierRequirements` - Computed tier requirements

### Budget Types

- `BudgetLimits` - Max files and LOC limits
- `ChangeStats` - Current change statistics
- `BudgetViolation` - Budget violation details
- `DerivedBudget` - Budget after waivers applied
- `BudgetUtilization` - Budget usage percentages

### Waiver Types

- `WaiverDocument` - Complete waiver document
- `WaiverApplication` - Applied waiver reference

## Type Safety Benefits

- **Compile-time checking**: Catch errors before runtime
- **IntelliSense support**: Auto-completion in IDEs
- **Documentation**: Types serve as inline documentation
- **Refactoring safety**: TypeScript ensures type consistency

## Version Compatibility

This package follows the CAWS CLI versioning:

- Major version matches CAWS CLI major version
- Minor/patch versions may diverge for type-only changes

## License

MIT
npm package: @pathscale/appstate-fast
Description: The flexible, fast and extendable state management for Vue that is based on hooks and state usage tracking.
Author: Bruce Wayne
Latest version: 0.0.4

<h1 align="center">
  Appstate-fast
</h1>

<p align="center">
  The simple but very powerful and incredibly fast state management for React that is based on hooks.
</p>
<br/>

<p align="center">
  <a href="https://vue3.dev">Why?</a> •
  <a href="https://vue3.dev/docs/getting-started">Docs / Samples</a> •
  <a href="https://vue3.dev/demo-todolist">Demo application</a> •
  <a href="https://vue3.dev/docs/extensions-overview">Plugins</a> •
  <a href="https://vue3.dev/blog/tags/releases">Release notes</a>
</p>

## Preface

Appstate-fast is a modern alternative to Redux, Mobx, Formik without boilerplate. It is simple to learn but very flexible to use. It has got impressive performance and predictable behavior.

**Any questions? Just ask by raising a github ticket.**

## Why Appstate-fast

[vue3.dev](https://vue3.dev)

## Migrating to version 2

[vue3.dev/docs/migrating-to-v2](https://vue3.dev/docs/migrating-to-v2)

## Documentation / Code samples

[vue3.dev/docs/getting-started](https://vue3.dev/docs/getting-started)

## Demo application

[vue3.dev/demo-todolist](https://vue3.dev/demo-todolist)

## Development tools

[vue3.dev/docs/devtools](https://vue3.dev/docs/devtools)

## Plugins / Extensions

[vue3.dev/docs/extensions-overview](https://vue3.dev/docs/extensions-overview)

## API reference

[vue3.dev/docs/typedoc-appstate-fast-core](https://vue3.dev/docs/typedoc-appstate-fast-core)
npm package: @pathscale/bulma-pull-2981-css-var-only
Description: Modern CSS framework based on Flexbox
Author: Jeremy Thomas
Latest version: 0.9.6-1

# Bulma + CSS Variables

Don't run `npm build` as that will override the current `css/bulma.css` file, which has been crafted by hand to overcome the following limitations:

PurgeCSS and therefore [rollup-plugin-vue3-ui-css-purge](https://www.npmjs.com/package/@pathscale/rollup-plugin-vue3-ui-css-purge) will do a bad job while purging unused css variables if the css do not comply with the following:

- Every css variable that depends on other variables will have be to be declared after their dependants
- Whenever commas are used to separate selectors, if one of those selectors it's body, it must go last
npm package: @pathscale/eslint-plugin-vue3
Description: Extra linting rules for clean Vue3
Author: PathScale
Latest version: 0.0.1

# @pathscale/eslint-plugin-vue3

linting rules to help enforce our rather limited view of the world.. Highly
opinionated and not for everyone

Currently requires `eslint-plugin-vue`.

## Installation

You'll first need to install [ESLint](http://eslint.org):

```
$ npm i eslint --save-dev
```

Next, install `@pathscale/eslint-plugin-vue3`:

```
$ npm install @pathscale/eslint-plugin-vue3 --save-dev
```

**Note:** If you installed ESLint globally (using the `-g` flag) then you must
also install `@pathscale/eslint-plugin-vue3` globally.

## Usage

Add `@pathscale/vue3` to the plugins section of your `.eslintrc` configuration
file. You can omit the `eslint-plugin-` prefix:

```json
{
    "plugins": [
        "@pathscale/vue3"
    ]
}
```


Then configure the rules you want to use under the rules section. Defaults
shown below.

```js
{
    "rules": {
        "@pathscale/vue3/v-directive": ["error", {
            // Add AST that should always be allowed
            "safe": [
                "Literal",
                "Identifier",
                // This only allows the inner template elements; one can still
                //   block `TemplateLiteral`
                "TemplateElement"
            ],

            // Add AST that should not be allowed
            "unsafe": [
                // These just add a single operator, so not blocked by default
                // 'SpreadElement',
                // 'UnaryExpression',

                // This can have design features so not blocking by default
                // 'TemplateLiteral',

                // Note: in avoiding these, one can use a call expression
                "AssignmentExpression",
                "BinaryExpression",
                "LogicalExpression",
                "ConditionalExpression",
            ],

            // Add AST that should not be allowed except at root
            "unsafeNested": [
                "CallExpression"
            ]
        }]
    }
}
```

## Supported Rules

- `@pathscale/vue3/v-directive` - See example above