open-index/open-npm huggingface dataset:
npm package: @robinpath/ratelimit
Description: Token bucket and sliding window rate limiting for RobinPath
Latest version: 0.1.2

# @robinpath/ratelimit

> Rate limiting with token bucket, sliding window, and fixed window algorithms

![Category](https://img.shields.io/badge/category-Infrastructure-blue) ![Functions](https://img.shields.io/badge/functions-8-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `ratelimit` module lets you:

- Create a named rate limiter (token-bucket, sliding-window, or fixed-window)
- Try to acquire tokens/slots from a rate limiter
- Check if a request would be allowed without consuming a token
- Get the number of remaining tokens/slots
- Wait until a token is available, then acquire it

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/ratelimit
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
ratelimit.acquire "api"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `ratelimit.create` | Create a named rate limiter (token-bucket, sliding-window, or fixed-window) |
| `ratelimit.acquire` | Try to acquire tokens/slots from a rate limiter |
| `ratelimit.check` | Check if a request would be allowed without consuming a token |
| `ratelimit.remaining` | Get the number of remaining tokens/slots |
| `ratelimit.wait` | Wait until a token is available, then acquire it |
| `ratelimit.reset` | Reset a rate limiter to its initial state |
| `ratelimit.status` | Get detailed status information for a rate limiter |
| `ratelimit.destroy` | Remove a rate limiter and free its resources |

## Examples

### Try to acquire tokens/slots from a rate limiter

```robinpath
ratelimit.acquire "api"
```

### Check if a request would be allowed without consuming a token

```robinpath
ratelimit.check "api"
```

### Get the number of remaining tokens/slots

```robinpath
ratelimit.remaining "api"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/ratelimit";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  ratelimit.acquire "api"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/regex
Description: Regular expression operations for pattern matching, searching, and replacing
Latest version: 0.1.1

# @robinpath/regex

> Regular expression operations for pattern matching, searching, and replacing

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-7-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `regex` module lets you:

- Test if a string matches a regular expression pattern
- Find the first match of a pattern in a string
- Find all matches of a pattern in a string
- Replace matches of a pattern in a string
- Split a string by a regular expression pattern

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/regex
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
regex.match "abc 123 def 456" "\d+"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `regex.test` | Test if a string matches a regular expression pattern |
| `regex.match` | Find the first match of a pattern in a string |
| `regex.matchAll` | Find all matches of a pattern in a string |
| `regex.replace` | Replace matches of a pattern in a string |
| `regex.split` | Split a string by a regular expression pattern |
| `regex.capture` | Extract capture groups from the first match of a pattern |
| `regex.escape` | Escape special regular expression characters in a string |

## Examples

### Find the first match of a pattern in a string

```robinpath
regex.match "abc 123 def 456" "\d+"
```

### Find all matches of a pattern in a string

```robinpath
regex.matchAll "abc 123 def 456" "\d+"
```

### Replace matches of a pattern in a string

```robinpath
regex.replace "abc 123 def 456" "\d+" "X"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/regex";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  regex.match "abc 123 def 456" "\d+"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/retry
Description: Retry with exponential backoff and circuit breaker for RobinPath
Latest version: 0.1.1

# @robinpath/retry

> Retry with exponential backoff and circuit breaker patterns for resilient automation workflows

![Category](https://img.shields.io/badge/category-Infrastructure-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `retry` module lets you:

- Execute a function with automatic retry and exponential backoff
- Calculate the delay for a given retry attempt using exponential backoff
- Check if an HTTP status code is retryable (408, 429, 500, 502, 503, 504)
- Wait for a specified number of milliseconds
- Preview the delay schedule for a series of retry attempts

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/retry
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
retry.withBackoff 3 1000 2 30000
```

## Available Functions

| Function | Description |
|----------|-------------|
| `retry.execute` | Execute a function with automatic retry and exponential backoff |
| `retry.withBackoff` | Calculate the delay for a given retry attempt using exponential backoff |
| `retry.isRetryable` | Check if an HTTP status code is retryable (408, 429, 500, 502, 503, 504) |
| `retry.delay` | Wait for a specified number of milliseconds |
| `retry.attempts` | Preview the delay schedule for a series of retry attempts |
| `retry.createBreaker` | Create a named circuit breaker with a failure threshold and reset timeout |
| `retry.breakerState` | Get the current state of a named circuit breaker |
| `retry.breakerRecord` | Record a success or failure in a circuit breaker |
| `retry.breakerAllow` | Check if a circuit breaker allows requests through |
| `retry.breakerReset` | Reset a circuit breaker to closed state |

## Examples

### Calculate the delay for a given retry attempt using exponential backoff

```robinpath
retry.withBackoff 3 1000 2 30000
```

### Check if an HTTP status code is retryable (408, 429, 500, 502, 503, 504)

```robinpath
retry.isRetryable 503
```

### Wait for a specified number of milliseconds

```robinpath
retry.delay 2000
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/retry";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  retry.withBackoff 3 1000 2 30000
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/robots
Description: robots.txt parsing, generation, URL permission checking, and crawl configuration
Latest version: 0.1.1

# @robinpath/robots

> robots.txt parsing, generation, URL permission checking, and crawl configuration

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-13-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `robots` module lets you:

- Parse robots.txt content
- Generate robots.txt
- Check if URL is allowed
- Check if URL is disallowed
- Get crawl delay for agent

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/robots
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
robots.create {"rules": [{"userAgent": "*", "disallow": ["/admin"]}]}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `robots.parse` | Parse robots.txt content |
| `robots.create` | Generate robots.txt |
| `robots.isAllowed` | Check if URL is allowed |
| `robots.isDisallowed` | Check if URL is disallowed |
| `robots.getCrawlDelay` | Get crawl delay for agent |
| `robots.getSitemaps` | Get sitemap URLs |
| `robots.getRules` | Get rules for agent |
| `robots.addRule` | Add rule to robots config |
| `robots.removeRule` | Remove rule by user agent |
| `robots.addSitemap` | Add sitemap URL |
| `robots.allowAll` | Generate allow-all robots.txt |
| `robots.disallowAll` | Generate disallow-all robots.txt |
| `robots.fetch` | Fetch and parse robots.txt from URL |

## Examples

### Generate robots.txt

```robinpath
robots.create {"rules": [{"userAgent": "*", "disallow": ["/admin"]}]}
```

### Check if URL is allowed

```robinpath
robots.isAllowed $robots "/page" "Googlebot"
```

### Check if URL is disallowed

```robinpath
robots.isDisallowed $robots "/admin"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/robots";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  robots.create {"rules": [{"userAgent": "*", "disallow": ["/admin"]}]}
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/router
Description: URL routing and pattern matching with support for path parameters (:param), wildcards (*), route groups, and middleware. No external dependencies.
Latest version: 0.1.1

# @robinpath/router

> URL routing and pattern matching with support for path parameters (:param), wildcards (*), route groups, and middleware. No external dependencies.

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-12-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `router` module lets you:

- Create a new router instance
- Add a route with method, path pattern, and handler
- Match a URL against registered routes and return the matching route
- Extract path parameters from a URL using a pattern
- Parse a URL into pathname, segments, and query parameters

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/router
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
router.add
```

## Available Functions

| Function | Description |
|----------|-------------|
| `router.create` | Create a new router instance |
| `router.add` | Add a route with method, path pattern, and handler |
| `router.match` | Match a URL against registered routes and return the matching route |
| `router.params` | Extract path parameters from a URL using a pattern |
| `router.parse` | Parse a URL into pathname, segments, and query parameters |
| `router.build` | Build a URL from a pattern and parameter values |
| `router.normalize` | Normalize a URL path (collapse slashes, ensure leading slash, strip trailing slash) |
| `router.isMatch` | Test if a URL path matches a route pattern |
| `router.group` | Create a route group with a shared prefix |
| `router.list` | List all routes registered in a router |
| `router.remove` | Remove routes by method and/or path |
| `router.middleware` | Add a middleware function to the router |

## Examples

### Add a route with method, path pattern, and handler

```robinpath
router.add
```

### Match a URL against registered routes and return the matching route

```robinpath
router.match
```

### Extract path parameters from a URL using a pattern

```robinpath
router.params
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/router";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  router.add
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/rss
Description: Parse RSS and Atom feeds, detect new entries
Latest version: 0.1.4

# @robinpath/rss

> Parse RSS and Atom feeds, detect new entries, and get feed metadata

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-6-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `rss` module lets you:

- Parse an RSS/Atom feed from a URL
- Parse RSS/Atom XML from a string
- Get feed items with a limit
- Get only new items since last check or since a date
- Get the most recent item from a feed

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/rss
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
rss.parseString $xmlContent
```

## Available Functions

| Function | Description |
|----------|-------------|
| `rss.parse` | Parse an RSS/Atom feed from a URL |
| `rss.parseString` | Parse RSS/Atom XML from a string |
| `rss.getItems` | Get feed items with a limit |
| `rss.getNew` | Get only new items since last check or since a date |
| `rss.getLatest` | Get the most recent item from a feed |
| `rss.feedInfo` | Get feed metadata without items |

## Examples

### Parse RSS/Atom XML from a string

```robinpath
rss.parseString $xmlContent
```

### Get feed items with a limit

```robinpath
rss.getItems "https://blog.example.com/feed" 5
```

### Get only new items since last check or since a date

```robinpath
rss.getNew "https://blog.example.com/feed" "2025-01-01"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/rss";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  rss.parseString $xmlContent
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/s3
Description: S3-compatible object storage operations using AWS Signature V4 over HTTPS
Latest version: 0.1.4

# @robinpath/s3

> S3-compatible object storage operations using AWS SDK

![Category](https://img.shields.io/badge/category-Cloud-storage-blue) ![Functions](https://img.shields.io/badge/functions-14-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `s3` module lets you:

- Upload an object to S3
- Download an object from S3
- Delete an object from S3
- List objects in an S3 bucket
- Check if an object exists in S3

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/s3
```

## Quick Start

**1. Set up credentials**

```robinpath
s3.configure "your-credentials"
```

**2. Upload an object to S3**

```robinpath
s3.upload
```

## Available Functions

| Function | Description |
|----------|-------------|
| `s3.configure` | Configure S3 client credentials and endpoint |
| `s3.upload` | Upload an object to S3 |
| `s3.download` | Download an object from S3 |
| `s3.remove` | Delete an object from S3 |
| `s3.list` | List objects in an S3 bucket |
| `s3.exists` | Check if an object exists in S3 |
| `s3.copy` | Copy an object within or between S3 buckets |
| `s3.move` | Move an object (copy then delete source) |
| `s3.presignUrl` | Generate a presigned URL for an S3 object |
| `s3.createBucket` | Create a new S3 bucket |
| `s3.deleteBucket` | Delete an S3 bucket |
| `s3.listBuckets` | List all S3 buckets |
| `s3.getMetadata` | Get metadata for an S3 object |
| `s3.setAcl` | Set the ACL for an S3 object |

## Examples

### Upload an object to S3

```robinpath
s3.upload
```

### Download an object from S3

```robinpath
s3.download
```

### Delete an object from S3

```robinpath
s3.remove
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/s3";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  s3.configure "your-credentials"
  s3.upload
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/dropbox`](../dropbox) — Dropbox module for complementary functionality
- [`@robinpath/box`](../box) — Box module for complementary functionality
- [`@robinpath/onedrive`](../onedrive) — OneDrive module for complementary functionality
- [`@robinpath/google-drive`](../google-drive) — Google Drive module for complementary functionality
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/sanity
Description: Sanity module for RobinPath.
Latest version: 0.1.1

# @robinpath/sanity

> Sanity module for RobinPath.

![Category](https://img.shields.io/badge/category-CMS-blue) ![Functions](https://img.shields.io/badge/functions-17-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `sanity` module lets you:

- query
- getDocument
- createDocument
- createOrReplace
- patch

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/sanity
```

## Quick Start

**1. Set up credentials**

```robinpath
sanity.setCredentials "your-credentials"
```

**2. query**

```robinpath
sanity.query
```

## Available Functions

| Function | Description |
|----------|-------------|
| `sanity.setCredentials` | Configure sanity credentials. |
| `sanity.query` | query |
| `sanity.getDocument` | getDocument |
| `sanity.createDocument` | createDocument |
| `sanity.createOrReplace` | createOrReplace |
| `sanity.patch` | patch |
| `sanity.deleteDocument` | deleteDocument |
| `sanity.uploadAsset` | uploadAsset |
| `sanity.getAsset` | getAsset |
| `sanity.listDatasets` | listDatasets |
| `sanity.createDataset` | createDataset |
| `sanity.deleteDataset` | deleteDataset |
| `sanity.mutate` | mutate |
| `sanity.listDocumentsByType` | listDocumentsByType |
| `sanity.getProject` | getProject |
| `sanity.exportDataset` | exportDataset |
| `sanity.importDataset` | importDataset |

## Examples

### query

```robinpath
sanity.query
```

### getDocument

```robinpath
sanity.getDocument
```

### createDocument

```robinpath
sanity.createDocument
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/sanity";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  sanity.setCredentials "your-credentials"
  sanity.query
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/scheduler
Description: Schedule and run recurring or one-time tasks with cron expressions, pause/resume support, and execution history
Latest version: 0.1.1

# @robinpath/scheduler

> Schedule and run recurring or one-time tasks with cron expressions, pause/resume support, and execution history

![Category](https://img.shields.io/badge/category-Infrastructure-blue) ![Functions](https://img.shields.io/badge/functions-11-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `scheduler` module lets you:

- Schedule a recurring task using a cron expression
- Schedule a one-time task at a specific date/time or after a delay in ms
- Cancel a scheduled task by id
- Cancel all scheduled tasks
- List all scheduled tasks with their next run times

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/scheduler
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
scheduler.once "sendEmail" "2025-12-31T23:59:00Z" { action: "sendNewYearEmail" }
```

## Available Functions

| Function | Description |
|----------|-------------|
| `scheduler.schedule` | Schedule a recurring task using a cron expression |
| `scheduler.once` | Schedule a one-time task at a specific date/time or after a delay in ms |
| `scheduler.cancel` | Cancel a scheduled task by id |
| `scheduler.cancelAll` | Cancel all scheduled tasks |
| `scheduler.list` | List all scheduled tasks with their next run times |
| `scheduler.get` | Get info about a specific scheduled task |
| `scheduler.pause` | Pause a scheduled task (keeps it but stops execution) |
| `scheduler.resume` | Resume a paused task |
| `scheduler.isRunning` | Check if a task is currently active (not paused and scheduled) |
| `scheduler.nextRun` | Get the next run time for a scheduled task |
| `scheduler.history` | Get execution history for a task |

## Examples

### Schedule a one-time task at a specific date/time or after a delay in ms

```robinpath
scheduler.once "sendEmail" "2025-12-31T23:59:00Z" { action: "sendNewYearEmail" }
```

### Cancel a scheduled task by id

```robinpath
scheduler.cancel "cleanup"
```

### Cancel all scheduled tasks

```robinpath
scheduler.cancelAll
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/scheduler";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  scheduler.once "sendEmail" "2025-12-31T23:59:00Z" { action: "sendNewYearEmail" }
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/schema
Description: Lightweight schema validation: validate data against type schemas with constraints
Latest version: 0.1.1

# @robinpath/schema

> Lightweight schema validation: validate data against type schemas with constraints

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `schema` module lets you:

- Validate data against a schema
- Check if data matches schema (boolean)
- Create a string schema
- Create a number schema
- Create a boolean schema

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/schema
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
schema.isValid $data $schema
```

## Available Functions

| Function | Description |
|----------|-------------|
| `schema.validate` | Validate data against a schema |
| `schema.isValid` | Check if data matches schema (boolean) |
| `schema.string` | Create a string schema |
| `schema.number` | Create a number schema |
| `schema.boolean` | Create a boolean schema |
| `schema.array` | Create an array schema |
| `schema.object` | Create an object schema |
| `schema.nullable` | Make a schema also accept null |
| `schema.oneOf` | Create a schema matching one of several schemas |
| `schema.getErrors` | Validate and return only the errors array |

## Examples

### Check if data matches schema (boolean)

```robinpath
schema.isValid $data $schema
```

### Create a string schema

```robinpath
schema.string {"minLength": 1}
```

### Create a number schema

```robinpath
schema.number {"min": 0, "max": 100}
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/schema";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  schema.isValid $data $schema
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/screen
Description: Screen capture and OCR: screenshots, region capture, window capture, and text extraction
Latest version: 0.1.3

# @robinpath/screen

> Screen capture and OCR: take screenshots (full, region, window), extract text from images with tesseract.js, list displays, and compare images

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-8-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `screen` module lets you:

- Take a full screenshot and save to file
- Capture a specific rectangular region of the screen
- Capture a specific window by its title (falls back to full screen if not found)
- Extract text from an image using OCR (tesseract.js)
- Extract text from a rectangular region of an image

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/screen
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
screen.captureRegion "./region.png" 100 100 400 300
```

## Available Functions

| Function | Description |
|----------|-------------|
| `screen.capture` | Take a full screenshot and save to file |
| `screen.captureRegion` | Capture a specific rectangular region of the screen |
| `screen.captureWindow` | Capture a specific window by its title (falls back to full screen if not found) |
| `screen.ocr` | Extract text from an image using OCR (tesseract.js) |
| `screen.ocrRegion` | Extract text from a rectangular region of an image |
| `screen.setLanguage` | Set the default OCR language (eng, rus, deu, fra, spa, chi_sim, jpn, kor, ron, etc.) |
| `screen.listDisplays` | List all available displays/monitors |
| `screen.compare` | Compare two images byte-by-byte to check if they are identical |

## Examples

### Capture a specific rectangular region of the screen

```robinpath
screen.captureRegion "./region.png" 100 100 400 300
```

### Capture a specific window by its title (falls back to full screen if not found)

```robinpath
screen.captureWindow "./notepad.png" "Untitled - Notepad"
```

### Extract text from an image using OCR (tesseract.js)

```robinpath
screen.ocr "./screenshot.png"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/screen";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  screen.captureRegion "./region.png" 100 100 400 300
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/sentry
Description: Sentry module for RobinPath.
Latest version: 0.1.1

# @robinpath/sentry

> Sentry module for RobinPath.

![Category](https://img.shields.io/badge/category-DevOps-blue) ![Functions](https://img.shields.io/badge/functions-19-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `sentry` module lets you:

- listProjects
- getProject
- listIssues
- getIssue
- updateIssue

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/sentry
```

## Quick Start

**1. Set up credentials**

```robinpath
sentry.setCredentials "your-credentials"
```

**2. listProjects**

```robinpath
sentry.listProjects
```

## Available Functions

| Function | Description |
|----------|-------------|
| `sentry.setCredentials` | Configure sentry credentials. |
| `sentry.listProjects` | listProjects |
| `sentry.getProject` | getProject |
| `sentry.listIssues` | listIssues |
| `sentry.getIssue` | getIssue |
| `sentry.updateIssue` | updateIssue |
| `sentry.deleteIssue` | deleteIssue |
| `sentry.listIssueEvents` | listIssueEvents |
| `sentry.getLatestEvent` | getLatestEvent |
| `sentry.listReleases` | listReleases |
| `sentry.createRelease` | createRelease |
| `sentry.listAlertRules` | listAlertRules |
| `sentry.createAlertRule` | createAlertRule |
| `sentry.resolveIssue` | resolveIssue |
| `sentry.ignoreIssue` | ignoreIssue |
| `sentry.assignIssue` | assignIssue |
| `sentry.listTeams` | listTeams |
| `sentry.getOrganization` | getOrganization |
| `sentry.listProjectKeys` | listProjectKeys |

## Examples

### listProjects

```robinpath
sentry.listProjects
```

### getProject

```robinpath
sentry.getProject
```

### listIssues

```robinpath
sentry.listIssues
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/sentry";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  sentry.setCredentials "your-credentials"
  sentry.listProjects
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/docker`](../docker) — Docker module for complementary functionality
- [`@robinpath/git`](../git) — Git module for complementary functionality
- [`@robinpath/github`](../github) — GitHub module for complementary functionality
- [`@robinpath/gitlab`](../gitlab) — GitLab module for complementary functionality
- [`@robinpath/vercel`](../vercel) — Vercel module for complementary functionality

## License

MIT
npm package: @robinpath/server
Description: HTTP server creation and management using Node.js built-in http module. Supports routing, static file serving, CORS, and common response helpers.
Latest version: 0.1.3

# @robinpath/server

> HTTP server creation and management using Node.js built-in http module. Supports routing, static file serving, CORS, and common response helpers.

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-15-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `server` module lets you:

- Create a new HTTP server instance
- Start listening for incoming connections
- Stop the server and close all connections
- Register a handler for all incoming requests
- Register an error handler for the server

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
robinpath add @robinpath/server
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
server.start
```

## Available Functions

| Function | Description |
|----------|-------------|
| `server.create` | Create a new HTTP server instance |
| `server.start` | Start listening for incoming connections |
| `server.stop` | Stop the server and close all connections |
| `server.onRequest` | Register a handler for all incoming requests |
| `server.onError` | Register an error handler for the server |
| `server.route` | Add a route with method, path pattern, and handler |
| `server.static` | Serve static files from a directory |
| `server.sendJson` | Send a JSON response |
| `server.sendHtml` | Send an HTML response |
| `server.sendFile` | Send a file as the response |
| `server.sendRedirect` | Send an HTTP redirect response |
| `server.status` | Send a response with a specific status code |
| `server.cors` | Enable and configure CORS headers for a server |
| `server.getServers` | List all active server instances |
| `server.getRoutes` | List all routes registered on a server |

## Examples

### Start listening for incoming connections

```robinpath
server.start
```

### Stop the server and close all connections

```robinpath
server.stop
```

### Register a handler for all incoming requests

```robinpath
server.onRequest
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/server";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  server.start
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/shopify
Description: Shopify module for RobinPath.
Latest version: 0.1.1

# @robinpath/shopify

> Shopify module for RobinPath.

![Category](https://img.shields.io/badge/category-E-Commerce-blue) ![Functions](https://img.shields.io/badge/functions-12-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `shopify` module lets you:

- List products in the store.
- Get a product by ID.
- Create a new product.
- Update an existing product.
- List orders with optional filters.

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/shopify
```

## Quick Start

**1. Set up credentials**

```robinpath
shopify.setCredentials "my-store" "shpat_xxx"
```

**2. List products in the store.**

```robinpath
shopify.listProducts {"limit":10}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `shopify.setCredentials` | Set Shopify store credentials. |
| `shopify.listProducts` | List products in the store. |
| `shopify.getProduct` | Get a product by ID. |
| `shopify.createProduct` | Create a new product. |
| `shopify.updateProduct` | Update an existing product. |
| `shopify.listOrders` | List orders with optional filters. |
| `shopify.getOrder` | Get an order by ID. |
| `shopify.listCustomers` | List customers. |
| `shopify.getCustomer` | Get a customer by ID. |
| `shopify.getInventory` | Get inventory levels for an item. |
| `shopify.countProducts` | Get total product count. |
| `shopify.countOrders` | Get total order count with optional status filter. |

## Examples

### List products in the store.

```robinpath
shopify.listProducts {"limit":10}
```

### Get a product by ID.

```robinpath
shopify.getProduct "123456789"
```

### Create a new product.

```robinpath
shopify.createProduct {"title":"New Product","body_html":"<p>Description</p>","vendor":"My Brand"}
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/shopify";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  shopify.setCredentials "my-store" "shpat_xxx"
  shopify.listProducts {"limit":10}
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/woocommerce`](../woocommerce) — WooCommerce module for complementary functionality
- [`@robinpath/bigcommerce`](../bigcommerce) — BigCommerce module for complementary functionality
- [`@robinpath/square`](../square) — Square module for complementary functionality
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/sitemap
Description: XML sitemap generation, parsing, validation, and manipulation with image/video/alternate support
Latest version: 0.1.1

# @robinpath/sitemap

> XML sitemap generation, parsing, validation, and manipulation with image/video/alternate support

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-13-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `sitemap` module lets you:

- Create XML sitemap
- Create sitemap index
- Parse XML sitemap
- Parse sitemap index
- Add URL to sitemap XML

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/sitemap
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
sitemap.createIndex [{"loc": "https://example.com/sitemap1.xml"}]
```

## Available Functions

| Function | Description |
|----------|-------------|
| `sitemap.create` | Create XML sitemap |
| `sitemap.createIndex` | Create sitemap index |
| `sitemap.parse` | Parse XML sitemap |
| `sitemap.parseIndex` | Parse sitemap index |
| `sitemap.addUrl` | Add URL to sitemap XML |
| `sitemap.removeUrl` | Remove URL from sitemap XML |
| `sitemap.filterByChangefreq` | Filter URLs by change frequency |
| `sitemap.filterByPriority` | Filter URLs by priority range |
| `sitemap.sortByPriority` | Sort URLs by priority |
| `sitemap.sortByLastmod` | Sort URLs by last modified |
| `sitemap.count` | Count URLs in sitemap |
| `sitemap.extractLocs` | Extract all loc URLs |
| `sitemap.validate` | Validate sitemap XML |

## Examples

### Create sitemap index

```robinpath
sitemap.createIndex [{"loc": "https://example.com/sitemap1.xml"}]
```

### Parse XML sitemap

```robinpath
sitemap.parse $xml
```

### Parse sitemap index

```robinpath
sitemap.parseIndex $xml
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/sitemap";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  sitemap.createIndex [{"loc": "https://example.com/sitemap1.xml"}]
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/sms
Description: SMS sending via Twilio and Vonage with validation, formatting, lookup, and cost estimation
Latest version: 0.1.1

# @robinpath/sms

> SMS sending via Twilio and Vonage with validation, formatting, lookup, and cost estimation

![Category](https://img.shields.io/badge/category-Messaging-blue) ![Functions](https://img.shields.io/badge/functions-10-green) ![Auth](https://img.shields.io/badge/auth-API%20Key-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `sms` module lets you:

- Send an SMS message
- Send SMS to multiple recipients
- Validate E.164 phone format
- Format phone to E.164
- Lookup phone info via Twilio

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/sms
```

## Quick Start

**1. Set up credentials**

```robinpath
sms.configure "main" {"provider": "twilio", "accountSid": "AC...", "authToken": "..."}
```

**2. Send an SMS message**

```robinpath
sms.send "main" "+15559876543" "Your code is 1234"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `sms.configure` | Configure SMS provider (Twilio or Vonage) |
| `sms.send` | Send an SMS message |
| `sms.sendBulk` | Send SMS to multiple recipients |
| `sms.validate` | Validate E.164 phone format |
| `sms.format` | Format phone to E.164 |
| `sms.lookup` | Lookup phone info via Twilio |
| `sms.status` | Check message delivery status |
| `sms.estimateCost` | Estimate SMS cost |
| `sms.isGsm` | Check if message uses GSM-7 encoding |
| `sms.segmentCount` | Count SMS segments |

## Examples

### Send an SMS message

```robinpath
sms.send "main" "+15559876543" "Your code is 1234"
```

### Send SMS to multiple recipients

```robinpath
sms.sendBulk "main" ["+155511111", "+155522222"] "Hello!"
```

### Validate E.164 phone format

```robinpath
sms.validate "+15551234567"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/sms";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  sms.configure "main" {"provider": "twilio", "accountSid": "AC...", "authToken": "..."}
  sms.send "main" "+15559876543" "Your code is 1234"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/slack`](../slack) — Slack module for complementary functionality
- [`@robinpath/discord`](../discord) — Discord module for complementary functionality
- [`@robinpath/teams`](../teams) — Teams module for complementary functionality
- [`@robinpath/telegram`](../telegram) — Telegram module for complementary functionality
- [`@robinpath/whatsapp`](../whatsapp) — WhatsApp module for complementary functionality

## License

MIT
npm package: @robinpath/soap
Description: SOAP web service client, XML-RPC support, WSDL parsing, and envelope building
Latest version: 0.1.1

# @robinpath/soap

> SOAP web service client, XML-RPC support, WSDL parsing, and envelope building

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-9-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `soap` module lets you:

- Call a SOAP web service
- Build SOAP XML envelope
- Parse SOAP XML response
- Call XML-RPC service
- Build XML-RPC request

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/soap
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
soap.buildEnvelope "GetUser" {"id": 1}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `soap.call` | Call a SOAP web service |
| `soap.buildEnvelope` | Build SOAP XML envelope |
| `soap.parseEnvelope` | Parse SOAP XML response |
| `soap.xmlRpc` | Call XML-RPC service |
| `soap.buildXmlRpc` | Build XML-RPC request |
| `soap.parseXmlRpc` | Parse XML-RPC response |
| `soap.wsdl` | Fetch and parse WSDL |
| `soap.fault` | Create SOAP fault XML |
| `soap.getFault` | Extract fault from SOAP XML |

## Examples

### Build SOAP XML envelope

```robinpath
soap.buildEnvelope "GetUser" {"id": 1}
```

### Parse SOAP XML response

```robinpath
soap.parseEnvelope $xml
```

### Call XML-RPC service

```robinpath
soap.xmlRpc "http://example.com/rpc" "system.listMethods" []
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/soap";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  soap.buildEnvelope "GetUser" {"id": 1}
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT