open-index/open-npm huggingface dataset:
npm package: @robinpath/facebook
Description: Facebook module for RobinPath.
Latest version: 0.1.1

# @robinpath/facebook

> Facebook module for RobinPath.

![Category](https://img.shields.io/badge/category-Social-media-blue) ![Functions](https://img.shields.io/badge/functions-21-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 `facebook` module lets you:

- getPageInfo
- listPagePosts
- createPagePost
- updatePost
- deletePost

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/facebook
```

## Quick Start

**1. Set up credentials**

```robinpath
facebook.setCredentials "your-credentials"
```

**2. getPageInfo**

```robinpath
facebook.getPageInfo
```

## Available Functions

| Function | Description |
|----------|-------------|
| `facebook.setCredentials` | Configure facebook credentials. |
| `facebook.getPageInfo` | getPageInfo |
| `facebook.listPagePosts` | listPagePosts |
| `facebook.createPagePost` | createPagePost |
| `facebook.updatePost` | updatePost |
| `facebook.deletePost` | deletePost |
| `facebook.getPost` | getPost |
| `facebook.getPostInsights` | getPostInsights |
| `facebook.getPageInsights` | getPageInsights |
| `facebook.listComments` | listComments |
| `facebook.replyToComment` | replyToComment |
| `facebook.deleteComment` | deleteComment |
| `facebook.hideComment` | hideComment |
| `facebook.listPageEvents` | listPageEvents |
| `facebook.createPageEvent` | createPageEvent |
| `facebook.uploadPhoto` | uploadPhoto |
| `facebook.uploadVideo` | uploadVideo |
| `facebook.getAdAccounts` | getAdAccounts |
| `facebook.getCampaigns` | getCampaigns |
| `facebook.getMe` | getMe |
| `facebook.searchPages` | searchPages |

## Examples

### getPageInfo

```robinpath
facebook.getPageInfo
```

### listPagePosts

```robinpath
facebook.listPagePosts
```

### createPagePost

```robinpath
facebook.createPagePost
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/facebook";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  facebook.setCredentials "your-credentials"
  facebook.getPageInfo
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/instagram`](../instagram) — Instagram module for complementary functionality
- [`@robinpath/twitter`](../twitter) — Twitter/X module for complementary functionality
- [`@robinpath/linkedin`](../linkedin) — LinkedIn module for complementary functionality
- [`@robinpath/tiktok`](../tiktok) — TikTok module for complementary functionality
- [`@robinpath/pinterest`](../pinterest) — Pinterest module for complementary functionality

## License

MIT
npm package: @robinpath/feed
Description: RSS, Atom, and JSON Feed creation, parsing, manipulation, and auto-detection
Latest version: 0.1.1

# @robinpath/feed

> RSS, Atom, and JSON Feed creation, parsing, manipulation, and auto-detection

![Category](https://img.shields.io/badge/category-Web-blue) ![Functions](https://img.shields.io/badge/functions-14-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `feed` module lets you:

- Create RSS 2.0 feed
- Create Atom feed
- Create JSON Feed
- Parse RSS feed
- Parse Atom feed

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/feed
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
feed.createAtom {"title": "My Blog", "link": "https://example.com", "items": [...]}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `feed.createRss` | Create RSS 2.0 feed |
| `feed.createAtom` | Create Atom feed |
| `feed.createJson` | Create JSON Feed |
| `feed.parseRss` | Parse RSS feed |
| `feed.parseAtom` | Parse Atom feed |
| `feed.parseJson` | Parse JSON Feed |
| `feed.detect` | Detect feed format |
| `feed.parse` | Auto-detect and parse any feed |
| `feed.addItem` | Add item to feed config |
| `feed.removeItem` | Remove item by guid |
| `feed.sortItems` | Sort items by date |
| `feed.filterItems` | Filter items by field regex |
| `feed.mergeFeeds` | Merge multiple feeds |
| `feed.fetch` | Fetch and parse feed from URL |

## Examples

### Create Atom feed

```robinpath
feed.createAtom {"title": "My Blog", "link": "https://example.com", "items": [...]}
```

### Create JSON Feed

```robinpath
feed.createJson {"title": "My Blog", "items": [...]}
```

### Parse RSS feed

```robinpath
feed.parseRss $xml
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/feed";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  feed.createAtom {"title": "My Blog", "link": "https://example.com", "items": [...]}
`);
```

## 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/formdata
Description: Multipart form data builder and file upload handling
Latest version: 0.1.1

# @robinpath/formdata

> Multipart form data builder, file uploads, URL encoding/decoding, and form submission

![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 `formdata` module lets you:

- Create a FormData object from key-value pairs
- Add a text field to a FormData
- Add a file to a FormData
- Submit a FormData to a URL
- URL-encode an object as application/x-www-form-urlencoded

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/formdata
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
formdata.addField $form "name" "Alice"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `formdata.create` | Create a FormData object from key-value pairs |
| `formdata.addField` | Add a text field to a FormData |
| `formdata.addFile` | Add a file to a FormData |
| `formdata.submit` | Submit a FormData to a URL |
| `formdata.encode` | URL-encode an object as application/x-www-form-urlencoded |
| `formdata.decode` | Decode a URL-encoded form body |
| `formdata.uploadFile` | Upload a file to a URL as multipart form |
| `formdata.parseMultipart` | Parse a multipart form body |

## Examples

### Add a text field to a FormData

```robinpath
formdata.addField $form "name" "Alice"
```

### Add a file to a FormData

```robinpath
formdata.addFile $form "avatar" "./photo.jpg"
```

### Submit a FormData to a URL

```robinpath
formdata.submit "https://api.example.com/upload" $form
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/formdata";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  formdata.addField $form "name" "Alice"
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/form`](../form) — Declarative form builder for defining form fields inline
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/freshbooks
Description: FreshBooks module for RobinPath.
Latest version: 0.1.1

# @robinpath/freshbooks

> FreshBooks module for RobinPath.

![Category](https://img.shields.io/badge/category-Finance-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 `freshbooks` module lets you:

- listClients
- getClient
- createClient
- updateClient
- listInvoices

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/freshbooks
```

## Quick Start

**1. Set up credentials**

```robinpath
freshbooks.setCredentials "your-credentials"
```

**2. listClients**

```robinpath
freshbooks.listClients
```

## Available Functions

| Function | Description |
|----------|-------------|
| `freshbooks.setCredentials` | Configure freshbooks credentials. |
| `freshbooks.listClients` | listClients |
| `freshbooks.getClient` | getClient |
| `freshbooks.createClient` | createClient |
| `freshbooks.updateClient` | updateClient |
| `freshbooks.listInvoices` | listInvoices |
| `freshbooks.getInvoice` | getInvoice |
| `freshbooks.createInvoice` | createInvoice |
| `freshbooks.updateInvoice` | updateInvoice |
| `freshbooks.sendInvoice` | sendInvoice |
| `freshbooks.listExpenses` | listExpenses |
| `freshbooks.getExpense` | getExpense |
| `freshbooks.createExpense` | createExpense |
| `freshbooks.listTimeEntries` | listTimeEntries |
| `freshbooks.createTimeEntry` | createTimeEntry |
| `freshbooks.listPayments` | listPayments |
| `freshbooks.createPayment` | createPayment |
| `freshbooks.getUser` | getUser |
| `freshbooks.getAccount` | getAccount |

## Examples

### listClients

```robinpath
freshbooks.listClients
```

### getClient

```robinpath
freshbooks.getClient
```

### createClient

```robinpath
freshbooks.createClient
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/freshbooks";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  freshbooks.setCredentials "your-credentials"
  freshbooks.listClients
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/quickbooks`](../quickbooks) — QuickBooks module for complementary functionality
- [`@robinpath/xero`](../xero) — Xero module for complementary functionality
- [`@robinpath/invoice`](../invoice) — Invoice module for complementary functionality
- [`@robinpath/json`](../json) — JSON module for complementary functionality

## License

MIT
npm package: @robinpath/fs
Description: Read, write, copy, move, and manage files and directories
Latest version: 0.1.3

# @robinpath/fs

> Read, write, copy, move, and manage files and directories

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-14-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `fs` module lets you:

- Read the contents of a file as a string
- Write content to a file, creating or overwriting it
- Append content to the end of a file
- Check whether a file or directory exists at the given path
- Delete a file

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
robinpath add @robinpath/fs
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
any "/tmp/file.txt" "hello world"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `fs.read` | Read the contents of a file as a string |
| `fs.write` | Write content to a file, creating or overwriting it |
| `fs.append` | Append content to the end of a file |
| `fs.exists` | Check whether a file or directory exists at the given path |
| `fs.delete` | Delete a file |
| `fs.copy` | Copy a file from source to destination |
| `fs.move` | Move or rename a file from source to destination |
| `fs.rename` | Rename a file (alias for move) |
| `fs.list` | List the contents of a directory |
| `fs.mkdir` | Create a directory (recursively creates parent directories) |
| `fs.rmdir` | Remove a directory and its contents |
| `fs.stat` | Get file or directory statistics |
| `fs.isFile` | Check whether a path points to a regular file |
| `fs.isDir` | Check whether a path points to a directory |

## Examples

### Write content to a file, creating or overwriting it

```robinpath
any "/tmp/file.txt" "hello world"
```

### Append content to the end of a file

```robinpath
any "/tmp/file.txt" "more text"
```

### Check whether a file or directory exists at the given path

```robinpath
any "/tmp/file.txt"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/fs";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  any "/tmp/file.txt" "hello world"
`);
```

## 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/ftp
Description: FTP and SFTP file transfer operations
Latest version: 0.1.3

# @robinpath/ftp

> FTP and SFTP file transfer: connect, upload, download, list, mkdir, rename, and delete

![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-connection-string-orange) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `ftp` module lets you:

- Upload a local file to remote server
- Download a remote file
- List files in a remote directory
- Create a remote directory
- Delete a remote file

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
robinpath add @robinpath/ftp
```

## Quick Start

**1. Set up credentials**

```robinpath
any "server" {"protocol": "sftp", "host": "example.com", "user": "admin", "pass": "..."}
```

**2. Upload a local file to remote server**

```robinpath
any "server" "./file.txt" "/remote/file.txt"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `ftp.connect` | Connect to an FTP or SFTP server |
| `ftp.upload` | Upload a local file to remote server |
| `ftp.download` | Download a remote file |
| `ftp.list` | List files in a remote directory |
| `ftp.mkdir` | Create a remote directory |
| `ftp.remove` | Delete a remote file |
| `ftp.rename` | Rename/move a remote file |
| `ftp.close` | Close an FTP/SFTP connection |

## Examples

### Upload a local file to remote server

```robinpath
any "server" "./file.txt" "/remote/file.txt"
```

### Download a remote file

```robinpath
any "server" "/remote/file.txt" "./file.txt"
```

### List files in a remote directory

```robinpath
any "server" "/uploads"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/ftp";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  any "server" {"protocol": "sftp", "host": "example.com", "user": "admin", "pass": "..."}
  any "server" "./file.txt" "/remote/file.txt"
`);
```

## 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/geo
Description: Geolocation utilities: distance, bearing, geocoding, bounding box, polygon containment, DMS conversion
Latest version: 0.1.1

# @robinpath/geo

> Geolocation utilities: distance, bearing, geocoding, bounding box, polygon containment, DMS conversion

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-14-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `geo` module lets you:

- Haversine distance between two points
- Bearing between two points
- Midpoint between two coordinates
- Destination point given start, bearing, and distance
- Bounding box around a point

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/geo
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
geo.bearing 40.7128 -74.0060 51.5074 -0.1278
```

## Available Functions

| Function | Description |
|----------|-------------|
| `geo.distance` | Haversine distance between two points |
| `geo.bearing` | Bearing between two points |
| `geo.midpoint` | Midpoint between two coordinates |
| `geo.destination` | Destination point given start, bearing, and distance |
| `geo.boundingBox` | Bounding box around a point |
| `geo.isInBoundingBox` | Check if point is inside bounding box |
| `geo.toRadians` | Convert degrees to radians |
| `geo.toDegrees` | Convert radians to degrees |
| `geo.toDMS` | Convert decimal degrees to DMS string |
| `geo.fromDMS` | Parse DMS string to decimal degrees |
| `geo.geocode` | Forward geocode address to coordinates |
| `geo.reverseGeocode` | Reverse geocode coordinates to address |
| `geo.polygon` | Check if point is inside polygon |
| `geo.area` | Calculate polygon area in sq km |

## Examples

### Bearing between two points

```robinpath
geo.bearing 40.7128 -74.0060 51.5074 -0.1278
```

### Midpoint between two coordinates

```robinpath
geo.midpoint 40.7128 -74.0060 51.5074 -0.1278
```

### Destination point given start, bearing, and distance

```robinpath
geo.destination 40.7128 -74.0060 45 100
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/geo";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  geo.bearing 40.7128 -74.0060 51.5074 -0.1278
`);
```

## 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/git
Description: Git version control operations using the system git binary
Latest version: 0.1.1

# @robinpath/git

> Git version control operations using the system git binary

![Category](https://img.shields.io/badge/category-DevOps-blue) ![Functions](https://img.shields.io/badge/functions-16-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `git` module lets you:

- Clone a git repository
- Initialize a new git repository
- Get the working tree status
- Stage files for commit
- Create a commit with the staged changes

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/git
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
git.init
```

## Available Functions

| Function | Description |
|----------|-------------|
| `git.clone` | Clone a git repository |
| `git.init` | Initialize a new git repository |
| `git.status` | Get the working tree status |
| `git.add` | Stage files for commit |
| `git.commit` | Create a commit with the staged changes |
| `git.push` | Push commits to a remote repository |
| `git.pull` | Pull changes from a remote repository |
| `git.branch` | List, create, or delete branches |
| `git.checkout` | Switch branches or restore working tree files |
| `git.log` | Show the commit log |
| `git.diff` | Show changes between commits, working tree, etc. |
| `git.tag` | Create or list tags |
| `git.remote` | List remote repositories |
| `git.merge` | Merge a branch into the current branch |
| `git.stash` | Stash or restore uncommitted changes |
| `git.reset` | Reset the current HEAD to a specified state |

## Examples

### Initialize a new git repository

```robinpath
git.init
```

### Get the working tree status

```robinpath
git.status
```

### Stage files for commit

```robinpath
git.add
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/git";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  git.init
`);
```

## 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/github`](../github) — GitHub module for complementary functionality
- [`@robinpath/gitlab`](../gitlab) — GitLab module for complementary functionality
- [`@robinpath/vercel`](../vercel) — Vercel module for complementary functionality
- [`@robinpath/netlify`](../netlify) — Netlify module for complementary functionality

## License

MIT
npm package: @robinpath/glob
Description: File pattern matching: find files by glob patterns, test matches, expand braces
Latest version: 0.1.1

# @robinpath/glob

> File pattern matching: find files by glob patterns, test matches, expand braces

![Category](https://img.shields.io/badge/category-Utility-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 `glob` module lets you:

- Find files matching a glob pattern
- Test if a path matches a glob pattern
- Convert a glob pattern to a regex string
- Expand brace pattern into array
- Extract non-glob base directory from pattern

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/glob
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
glob.isMatch "src/index.ts" "**/*.ts"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `glob.match` | Find files matching a glob pattern |
| `glob.isMatch` | Test if a path matches a glob pattern |
| `glob.toRegex` | Convert a glob pattern to a regex string |
| `glob.expand` | Expand brace pattern into array |
| `glob.base` | Extract non-glob base directory from pattern |
| `glob.hasMagic` | Check if string contains glob characters |

## Examples

### Test if a path matches a glob pattern

```robinpath
glob.isMatch "src/index.ts" "**/*.ts"
```

### Convert a glob pattern to a regex string

```robinpath
glob.toRegex "*.ts"
```

### Expand brace pattern into array

```robinpath
glob.expand "file.{ts,js}"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/glob";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  glob.isMatch "src/index.ts" "**/*.ts"
`);
```

## 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/gmail
Description: Gmail module for RobinPath.
Latest version: 0.1.1

# @robinpath/gmail

> Gmail module for RobinPath.

![Category](https://img.shields.io/badge/category-Productivity-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 `gmail` module lets you:

- List/search messages
- Get message details
- Send a plain text email
- Move message to trash
- Remove from trash

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/gmail
```

## Quick Start

**1. Set up credentials**

```robinpath
gmail.setCredentials "your-credentials"
```

**2. List/search messages**

```robinpath
gmail.listMessages
```

## Available Functions

| Function | Description |
|----------|-------------|
| `gmail.setCredentials` | Configure Gmail OAuth2 credentials. |
| `gmail.listMessages` | List/search messages |
| `gmail.getMessage` | Get message details |
| `gmail.sendEmail` | Send a plain text email |
| `gmail.trashMessage` | Move message to trash |
| `gmail.untrashMessage` | Remove from trash |
| `gmail.deleteMessage` | Permanently delete message |
| `gmail.modifyLabels` | Add/remove labels |
| `gmail.markAsRead` | Mark as read |
| `gmail.markAsUnread` | Mark as unread |
| `gmail.listLabels` | List all labels |
| `gmail.createLabel` | Create a label |
| `gmail.createDraft` | Create a draft |
| `gmail.listDrafts` | List drafts |
| `gmail.sendDraft` | Send a draft |
| `gmail.deleteDraft` | Delete a draft |
| `gmail.getProfile` | Get user profile |

## Examples

### List/search messages

```robinpath
gmail.listMessages
```

### Get message details

```robinpath
gmail.getMessage
```

### Send a plain text email

```robinpath
gmail.sendEmail
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/gmail";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  gmail.setCredentials "your-credentials"
  gmail.listMessages
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/google-sheets`](../google-sheets) — Google Sheets module for complementary functionality
- [`@robinpath/google-calendar`](../google-calendar) — Google Calendar module for complementary functionality
- [`@robinpath/google-contacts`](../google-contacts) — Google Contacts module for complementary functionality
- [`@robinpath/google-forms`](../google-forms) — Google Forms module for complementary functionality
- [`@robinpath/outlook`](../outlook) — Outlook module for complementary functionality

## License

MIT
npm package: @robinpath/google-forms
Description: Google Forms module for RobinPath.
Latest version: 0.1.1

# @robinpath/google-forms

> Google Forms module for RobinPath.

![Category](https://img.shields.io/badge/category-Productivity-blue) ![Functions](https://img.shields.io/badge/functions-13-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 `google-forms` module lets you:

- getForm
- createForm
- updateForm
- listResponses
- getResponse

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/google-forms
```

## Quick Start

**1. Set up credentials**

```robinpath
google-forms.setCredentials "your-credentials"
```

**2. getForm**

```robinpath
google-forms.getForm
```

## Available Functions

| Function | Description |
|----------|-------------|
| `google-forms.setCredentials` | Configure google-forms credentials. |
| `google-forms.getForm` | getForm |
| `google-forms.createForm` | createForm |
| `google-forms.updateForm` | updateForm |
| `google-forms.listResponses` | listResponses |
| `google-forms.getResponse` | getResponse |
| `google-forms.addQuestion` | addQuestion |
| `google-forms.updateQuestion` | updateQuestion |
| `google-forms.deleteQuestion` | deleteQuestion |
| `google-forms.addSection` | addSection |
| `google-forms.getFormInfo` | getFormInfo |
| `google-forms.batchUpdate` | batchUpdate |
| `google-forms.convertToQuiz` | convertToQuiz |

## Examples

### getForm

```robinpath
google-forms.getForm
```

### createForm

```robinpath
google-forms.createForm
```

### updateForm

```robinpath
google-forms.updateForm
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/google-forms";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  google-forms.setCredentials "your-credentials"
  google-forms.getForm
`);
```

## Full API Reference

See [MODULE.md](./MODULE.md) for complete documentation including all parameters, return types, error handling, and advanced examples.

## Related Modules

- [`@robinpath/google-sheets`](../google-sheets) — Google Sheets module for complementary functionality
- [`@robinpath/google-calendar`](../google-calendar) — Google Calendar module for complementary functionality
- [`@robinpath/google-contacts`](../google-contacts) — Google Contacts module for complementary functionality
- [`@robinpath/gmail`](../gmail) — Gmail module for complementary functionality
- [`@robinpath/outlook`](../outlook) — Outlook module for complementary functionality

## License

MIT
npm package: @robinpath/graph
Description: Graph data structures with BFS, DFS, Dijkstra's shortest path, topological sort, cycle detection, and connectivity
Latest version: 0.1.1

# @robinpath/graph

> Graph data structures with BFS, DFS, Dijkstra's shortest path, topological sort, cycle detection, and connectivity

![Category](https://img.shields.io/badge/category-Analytics-blue) ![Functions](https://img.shields.io/badge/functions-19-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `graph` module lets you:

- Create graph
- Add node
- Add edge
- Remove node and its edges
- Remove edge

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/graph
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
graph.addNode "A" {"label": "Start"}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `graph.create` | Create graph |
| `graph.addNode` | Add node |
| `graph.addEdge` | Add edge |
| `graph.removeNode` | Remove node and its edges |
| `graph.removeEdge` | Remove edge |
| `graph.nodes` | List all nodes |
| `graph.edges` | List all edges |
| `graph.neighbors` | Get node neighbors |
| `graph.degree` | Get node degree |
| `graph.bfs` | Breadth-first search |
| `graph.dfs` | Depth-first search |
| `graph.shortestPath` | Dijkstra's shortest path |
| `graph.topologicalSort` | Topological sort (DAG only) |
| `graph.hasCycle` | Check for cycles |
| `graph.isConnected` | Check if graph is connected |
| `graph.hasPath` | Check if path exists between nodes |
| `graph.size` | Get graph size |
| `graph.destroy` | Destroy graph |
| `graph.list` | List all graphs |

## Examples

### Add node

```robinpath
graph.addNode "A" {"label": "Start"}
```

### Add edge

```robinpath
graph.addEdge "A" "B" 5
```

### Remove node and its edges

```robinpath
graph.removeNode "A"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/graph";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  graph.addNode "A" {"label": "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/graphql
Description: GraphQL client with queries, mutations, variables, and introspection
Latest version: 0.1.1

# @robinpath/graphql

> GraphQL client with queries, mutations, variables, introspection, batch requests, and query builder

![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 `graphql` module lets you:

- Create a named GraphQL client
- Execute a GraphQL query
- Execute a GraphQL mutation
- Send a one-off GraphQL request without creating a client
- Run an introspection query to discover the schema

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/graphql
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
graphql.query "github" "{ viewer { login name } }"
```

## Available Functions

| Function | Description |
|----------|-------------|
| `graphql.create` | Create a named GraphQL client |
| `graphql.query` | Execute a GraphQL query |
| `graphql.mutate` | Execute a GraphQL mutation |
| `graphql.rawRequest` | Send a one-off GraphQL request without creating a client |
| `graphql.introspect` | Run an introspection query to discover the schema |
| `graphql.listTypes` | List all types in the GraphQL schema |
| `graphql.buildQuery` | Build a simple GraphQL query string from parts |
| `graphql.batchQuery` | Execute multiple queries sequentially |
| `graphql.destroy` | Remove a GraphQL client |

## Examples

### Execute a GraphQL query

```robinpath
graphql.query "github" "{ viewer { login name } }"
```

### Execute a GraphQL mutation

```robinpath
graphql.mutate "api" "mutation { createUser(name: $name) { id } }" {"name": "Alice"}
```

### Send a one-off GraphQL request without creating a client

```robinpath
graphql.rawRequest "https://api.example.com/graphql" "{ users { id } }"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/graphql";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  graphql.query "github" "{ viewer { login name } }"
`);
```

## 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/hash
Description: Cryptographic hashing utilities: MD5, SHA family, HMAC, CRC32, file hashing, UUID v5 generation, secure random bytes, and content fingerprinting
Latest version: 0.1.3

# @robinpath/hash

> Cryptographic hashing utilities: MD5, SHA family, HMAC, CRC32, file hashing, UUID v5 generation, secure random bytes, and content fingerprinting

![Category](https://img.shields.io/badge/category-Utility-blue) ![Functions](https://img.shields.io/badge/functions-16-green) ![Auth](https://img.shields.io/badge/auth-none-lightgrey) ![License](https://img.shields.io/badge/license-MIT-brightgreen)

## Why use this module?

The `hash` module lets you:

- Compute MD5 hash of a string
- Compute SHA-1 hash of a string
- Compute SHA-256 hash of a string
- Compute SHA-512 hash of a string
- Compute SHA-3 hash of a string

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
robinpath add @robinpath/hash
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
hash.sha1
```

## Available Functions

| Function | Description |
|----------|-------------|
| `hash.md5` | Compute MD5 hash of a string |
| `hash.sha1` | Compute SHA-1 hash of a string |
| `hash.sha256` | Compute SHA-256 hash of a string |
| `hash.sha512` | Compute SHA-512 hash of a string |
| `hash.sha3` | Compute SHA-3 hash of a string |
| `hash.hmac` | Compute HMAC of a string with a secret key |
| `hash.hashFile` | Compute the hash of a file's contents |
| `hash.hashStream` | Compute a hash from an array of data chunks (simulates stream hashing) |
| `hash.crc32` | Compute CRC32 checksum of a string |
| `hash.checksum` | Verify that a string matches an expected hash |
| `hash.compare` | Timing-safe comparison of two strings to prevent timing attacks |
| `hash.uuid5` | Generate a deterministic UUID v5 from a name and namespace |
| `hash.randomBytes` | Generate cryptographically secure random bytes |
| `hash.randomHex` | Generate a random hexadecimal string of specified length |
| `hash.randomBase64` | Generate a random Base64-encoded string |
| `hash.fingerprint` | Generate a content fingerprint combining MD5 and SHA-256 hashes |

## Examples

### Compute SHA-1 hash of a string

```robinpath
hash.sha1
```

### Compute SHA-256 hash of a string

```robinpath
hash.sha256
```

### Compute SHA-512 hash of a string

```robinpath
hash.sha512
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/hash";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  hash.sha1
`);
```

## 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/hotjar
Description: Hotjar module for RobinPath.
Latest version: 0.1.1

# @robinpath/hotjar

> Hotjar module for RobinPath.

![Category](https://img.shields.io/badge/category-Analytics-blue) ![Functions](https://img.shields.io/badge/functions-13-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 `hotjar` module lets you:

- listSurveys
- getSurvey
- getSurveyResponses
- listFeedback
- getFeedbackItem

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/hotjar
```

## Quick Start

**1. Set up credentials**

```robinpath
hotjar.setCredentials "your-credentials"
```

**2. listSurveys**

```robinpath
hotjar.listSurveys
```

## Available Functions

| Function | Description |
|----------|-------------|
| `hotjar.setCredentials` | Configure hotjar credentials. |
| `hotjar.listSurveys` | listSurveys |
| `hotjar.getSurvey` | getSurvey |
| `hotjar.getSurveyResponses` | getSurveyResponses |
| `hotjar.listFeedback` | listFeedback |
| `hotjar.getFeedbackItem` | getFeedbackItem |
| `hotjar.listHeatmaps` | listHeatmaps |
| `hotjar.getHeatmap` | getHeatmap |
| `hotjar.listRecordings` | listRecordings |
| `hotjar.getRecording` | getRecording |
| `hotjar.getSiteInfo` | getSiteInfo |
| `hotjar.getUserInfo` | getUserInfo |
| `hotjar.getSessionCount` | getSessionCount |

## Examples

### listSurveys

```robinpath
hotjar.listSurveys
```

### getSurvey

```robinpath
hotjar.getSurvey
```

### getSurveyResponses

```robinpath
hotjar.getSurveyResponses
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/hotjar";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  hotjar.setCredentials "your-credentials"
  hotjar.listSurveys
`);
```

## 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/i18n
Description: Internationalization: translations, number/currency/date formatting, relative time, pluralization, RTL detection
Latest version: 0.1.1

# @robinpath/i18n

> Internationalization: translations, number/currency/date formatting, relative time, pluralization, RTL detection

![Category](https://img.shields.io/badge/category-Other-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 `i18n` module lets you:

- Get current locale
- Load translations for a locale
- Translate a key
- Format number for locale
- Format currency

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/i18n
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
i18n.getLocale
```

## Available Functions

| Function | Description |
|----------|-------------|
| `i18n.setLocale` | Set default locale |
| `i18n.getLocale` | Get current locale |
| `i18n.loadTranslations` | Load translations for a locale |
| `i18n.t` | Translate a key |
| `i18n.formatNumber` | Format number for locale |
| `i18n.formatCurrency` | Format currency |
| `i18n.formatDate` | Format date for locale |
| `i18n.formatRelativeTime` | Format relative time |
| `i18n.formatList` | Format list (A, B, and C) |
| `i18n.pluralize` | Simple pluralization |
| `i18n.direction` | Get text direction for locale |
| `i18n.listLocales` | List loaded translation locales |
| `i18n.hasTranslation` | Check if key exists |
| `i18n.languageName` | Get language display name |
| `i18n.regionName` | Get region display name |

## Examples

### Get current locale

```robinpath
i18n.getLocale
```

### Load translations for a locale

```robinpath
i18n.loadTranslations "es" {"hello": "Hola", "bye": "Adiós"}
```

### Translate a key

```robinpath
i18n.t "hello" "es"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/i18n";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  i18n.getLocale
`);
```

## 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/image
Description: Image processing: resize, crop, convert, watermark, and metadata
Latest version: 0.1.1

# @robinpath/image

> Image processing with Sharp: resize, crop, convert, rotate, flip, grayscale, blur, composite/watermark, and thumbnails

![Category](https://img.shields.io/badge/category-Other-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 `image` module lets you:

- Resize an image
- Crop a region from an image
- Convert image format (png, jpeg, webp, avif)
- Get image metadata
- Rotate an image

All functions are callable directly from RobinPath scripts with a simple, consistent API.

## Installation

```bash
npm install @robinpath/image
```

## Quick Start

No credentials needed — start using it right away:

```robinpath
image.crop "./photo.jpg" "./cropped.jpg" {"left": 10, "top": 10, "width": 200, "height": 200}
```

## Available Functions

| Function | Description |
|----------|-------------|
| `image.resize` | Resize an image |
| `image.crop` | Crop a region from an image |
| `image.convert` | Convert image format (png, jpeg, webp, avif) |
| `image.metadata` | Get image metadata |
| `image.rotate` | Rotate an image |
| `image.flip` | Flip an image vertically or horizontally |
| `image.grayscale` | Convert to grayscale |
| `image.blur` | Apply Gaussian blur |
| `image.composite` | Overlay one image on top of another (watermark) |
| `image.thumbnail` | Generate a square thumbnail |

## Examples

### Crop a region from an image

```robinpath
image.crop "./photo.jpg" "./cropped.jpg" {"left": 10, "top": 10, "width": 200, "height": 200}
```

### Convert image format (png, jpeg, webp, avif)

```robinpath
image.convert "./photo.png" "./photo.webp" "webp" 85
```

### Get image metadata

```robinpath
image.metadata "./photo.jpg"
```

## Integration with RobinPath

```typescript
import { RobinPath } from "@wiredwp/robinpath";
import Module from "@robinpath/image";

const rp = new RobinPath();
rp.registerModule(Module.name, Module.functions);
rp.registerModuleMeta(Module.name, Module.functionMetadata);

const result = await rp.executeScript(`
  image.crop "./photo.jpg" "./cropped.jpg" {"left": 10, "top": 10, "width": 200, "height": 200}
`);
```

## 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