# ConveniencePro - Complete Documentation

> Privacy-focused developer utility tools with client-side processing. All tools run in your browser - no data is ever sent to servers.

## Overview

ConveniencePro provides 25+ developer utility tools designed for:
1. Direct browser use via the website
2. LLM integration via URL-as-API pattern
3. Embedding in third-party applications
4. Programmatic use via JavaScript SDK

All processing happens client-side. The server only delivers static files - no user data ever touches our infrastructure.

---

## LLM Integration Guide

### The URL-as-API Pattern

ConveniencePro implements a novel pattern for LLM tool integration without server-side infrastructure:

1. **Discovery**: LLM reads `/.well-known/ai-tools.json` to learn available tools
2. **Invocation**: LLM constructs URL with tool name and parameters
3. **Execution**: Browser loads page, JavaScript processes locally
4. **Response**: Result renders as JSON in page content

This approach means:
- No API keys required
- No rate limits
- No server-side processing
- Complete privacy for user data

### URL Structure

```
https://conveniencepro.cc/run/{tool-id}?{parameters}
```

### Response Format

All tools return JSON with this structure:
```json
{
  "success": true,
  "result_field": "value",
  "_meta": {
    "tool": "tool-id",
    "description": "Tool description",
    "category": "category",
    "provider": "ConveniencePro",
    "timestamp": "2024-01-01T00:00:00.000Z",
    "note": "All processing performed client-side."
  }
}
```

On error:
```json
{
  "success": false,
  "error": "Error message"
}
```

---

## Complete Tool Reference

### base64-encode

Encode text to Base64 format.

**URL**: `/run/base64-encode?text={text}&urlSafe={true|false}`

**Parameters**:
- `text` (required): Text to encode
- `urlSafe` (optional): Use URL-safe encoding (default: false)

**Response**:
```json
{
  "success": true,
  "encoded": "SGVsbG8gV29ybGQ=",
  "length": 16,
  "urlSafe": false
}
```

**Example**: `/run/base64-encode?text=Hello%20World`

---

### base64-decode

Decode Base64 to text.

**URL**: `/run/base64-decode?input={base64}`

**Parameters**:
- `input` (required): Base64 string to decode

**Response**:
```json
{
  "success": true,
  "decoded": "Hello World",
  "length": 11
}
```

---

### url-encode

URL encode text (percent encoding).

**URL**: `/run/url-encode?text={text}`

**Parameters**:
- `text` (required): Text to encode

**Response**:
```json
{
  "success": true,
  "encoded": "Hello%20World",
  "original": "Hello World"
}
```

---

### url-decode

Decode URL-encoded text.

**URL**: `/run/url-decode?input={encoded}`

**Parameters**:
- `input` (required): URL-encoded text

**Response**:
```json
{
  "success": true,
  "decoded": "Hello World",
  "original": "Hello%20World"
}
```

---

### html-encode

Escape HTML special characters.

**URL**: `/run/html-encode?text={text}`

**Parameters**:
- `text` (required): Text to encode

**Response**:
```json
{
  "success": true,
  "encoded": "<div>Hello</div>"
}
```

---

### html-decode

Unescape HTML entities.

**URL**: `/run/html-decode?input={encoded}`

**Parameters**:
- `input` (required): HTML-encoded text

**Response**:
```json
{
  "success": true,
  "decoded": "<div>Hello</div>"
}
```

---

### json-format

Format/beautify JSON with indentation.

**URL**: `/run/json-format?json={json}&indent={number}`

**Parameters**:
- `json` (required): JSON string to format
- `input` (alternative): Base64-encoded JSON
- `indent` (optional): Spaces for indentation (default: 2)

**Response**:
```json
{
  "success": true,
  "formatted": "{\n  \"key\": \"value\"\n}",
  "valid": true,
  "type": "object",
  "keys": 1
}
```

---

### json-minify

Remove whitespace from JSON.

**URL**: `/run/json-minify?json={json}`

**Parameters**:
- `json` (required): JSON string to minify
- `input` (alternative): Base64-encoded JSON

**Response**:
```json
{
  "success": true,
  "minified": "{\"key\":\"value\"}",
  "originalLength": 20,
  "minifiedLength": 15,
  "reduction": "25%"
}
```

---

### json-validate

Check if JSON is valid.

**URL**: `/run/json-validate?json={json}`

**Parameters**:
- `json` (required): JSON string to validate
- `input` (alternative): Base64-encoded JSON

**Response**:
```json
{
  "success": true,
  "valid": true,
  "type": "object",
  "depth": 2,
  "keys": 3
}
```

---

### hash-sha256

Generate SHA-256 hash.

**URL**: `/run/hash-sha256?text={text}`

**Parameters**:
- `text` (required): Text to hash

**Response**:
```json
{
  "success": true,
  "hash": "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e",
  "algorithm": "SHA-256",
  "inputLength": 5
}
```

---

### hash-sha512

Generate SHA-512 hash.

**URL**: `/run/hash-sha512?text={text}`

**Parameters**:
- `text` (required): Text to hash

**Response**:
```json
{
  "success": true,
  "hash": "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043",
  "algorithm": "SHA-512",
  "inputLength": 5
}
```

---

### hash-sha1

Generate SHA-1 hash (deprecated for security).

**URL**: `/run/hash-sha1?text={text}`

**Parameters**:
- `text` (required): Text to hash

**Response**:
```json
{
  "success": true,
  "hash": "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d",
  "algorithm": "SHA-1",
  "inputLength": 5,
  "note": "SHA-1 is deprecated for security purposes."
}
```

---

### hash-md5

Generate MD5 hash (not cryptographically secure).

**URL**: `/run/hash-md5?text={text}`

**Parameters**:
- `text` (required): Text to hash

**Response**:
```json
{
  "success": true,
  "hash": "5d41402abc4b2a76b9719d911017c592",
  "algorithm": "MD5",
  "inputLength": 5,
  "note": "MD5 is not secure for cryptographic purposes."
}
```

---

### uuid-generate

Generate UUID v4.

**URL**: `/run/uuid-generate?count={number}`

**Parameters**:
- `count` (optional): Number of UUIDs to generate (default: 1, max: 100)

**Response**:
```json
{
  "success": true,
  "uuid": "550e8400-e29b-41d4-a716-446655440000",
  "count": 1,
  "version": 4
}
```

For multiple:
```json
{
  "success": true,
  "uuids": ["uuid1", "uuid2", "uuid3"],
  "count": 3,
  "version": 4
}
```

---

### uuid-validate

Validate UUID format and extract version.

**URL**: `/run/uuid-validate?uuid={uuid}`

**Parameters**:
- `uuid` (required): UUID to validate

**Response**:
```json
{
  "success": true,
  "valid": true,
  "version": 4,
  "uuid": "550e8400-e29b-41d4-a716-446655440000"
}
```

---

### regex-test

Test a regex pattern against text.

**URL**: `/run/regex-test?pattern={pattern}&text={text}&flags={flags}`

**Parameters**:
- `pattern` (required): Regular expression pattern
- `text` (required): Text to test against
- `flags` (optional): Regex flags (default: "g")

**Response**:
```json
{
  "success": true,
  "matches": [
    {
      "match": "123",
      "index": 0,
      "groups": null,
      "captures": []
    }
  ],
  "count": 1,
  "pattern": "\\d+",
  "flags": "g"
}
```

---

### regex-replace

Replace text using regex.

**URL**: `/run/regex-replace?pattern={pattern}&text={text}&replacement={replacement}&flags={flags}`

**Parameters**:
- `pattern` (required): Regular expression pattern
- `text` (required): Text to perform replacement on
- `replacement` (optional): Replacement string (default: "")
- `flags` (optional): Regex flags (default: "g")

**Response**:
```json
{
  "success": true,
  "result": "abc",
  "replacements": 2,
  "pattern": "\\d+",
  "flags": "g"
}
```

---

### text-stats

Get statistics about text.

**URL**: `/run/text-stats?text={text}`

**Parameters**:
- `text` (required): Text to analyze
- `input` (alternative): Base64-encoded text

**Response**:
```json
{
  "success": true,
  "characters": 100,
  "charactersNoSpaces": 85,
  "words": 20,
  "sentences": 3,
  "paragraphs": 1,
  "lines": 5,
  "averageWordLength": 4.2
}
```

---

### case-convert

Convert text between different cases.

**URL**: `/run/case-convert?text={text}&to={case}`

**Parameters**:
- `text` (required): Text to convert
- `to` (required): Target case type

**Case Types**:
- `upper` / `uppercase`
- `lower` / `lowercase`
- `title` / `titlecase`
- `sentence` / `sentencecase`
- `camel` / `camelcase`
- `pascal` / `pascalcase`
- `snake` / `snakecase` / `snake_case`
- `kebab` / `kebabcase` / `kebab-case`
- `constant` / `constantcase` / `constant_case`

**Response**:
```json
{
  "success": true,
  "result": "helloWorld",
  "from": "hello world",
  "to": "camel"
}
```

---

### text-reverse

Reverse text by characters, words, or lines.

**URL**: `/run/text-reverse?text={text}&mode={mode}`

**Parameters**:
- `text` (required): Text to reverse
- `mode` (optional): Reversal mode (default: "characters")
  - `characters` / `chars`
  - `words`
  - `lines`

**Response**:
```json
{
  "success": true,
  "result": "dlroW olleH",
  "mode": "characters"
}
```

---

### text-trim

Trim whitespace from text.

**URL**: `/run/text-trim?text={text}&mode={mode}`

**Parameters**:
- `text` (required): Text to trim
- `input` (alternative): Base64-encoded text
- `mode` (optional): Trim mode (default: "both")
  - `both` - Trim start and end
  - `start` / `left`
  - `end` / `right`
  - `lines` - Trim each line
  - `all` - Collapse all whitespace

**Response**:
```json
{
  "success": true,
  "result": "trimmed text",
  "originalLength": 20,
  "trimmedLength": 12,
  "removed": 8
}
```

---

### number-format

Format numbers with locale and style.

**URL**: `/run/number-format?value={number}&locale={locale}&style={style}&currency={code}&decimals={number}`

**Parameters**:
- `value` (required): Number to format
- `locale` (optional): Locale code (default: "en-US")
- `style` (optional): Format style (default: "decimal")
  - `decimal`
  - `currency`
  - `percent`
- `currency` (optional): Currency code for style=currency (default: "USD")
- `decimals` (optional): Decimal places

**Response**:
```json
{
  "success": true,
  "formatted": "$1,234.56",
  "value": 1234.56,
  "locale": "en-US",
  "style": "currency"
}
```

---

### number-base

Convert numbers between bases.

**URL**: `/run/number-base?value={value}&from={base}&to={base}`

**Parameters**:
- `value` (required): Number to convert
- `from` (optional): Source base (default: 10)
- `to` (optional): Target base (default: 16)

**Note**: Bases must be between 2 and 36.

**Response**:
```json
{
  "success": true,
  "result": "ff",
  "value": "255",
  "fromBase": 10,
  "toBase": 16,
  "decimal": 255
}
```

---

### timestamp

Convert between timestamp formats.

**URL**: `/run/timestamp?value={timestamp}`

**Parameters**:
- `value` (optional): Timestamp or date string (default: "now")
  - Unix seconds: `1704067200`
  - Unix milliseconds: `1704067200000`
  - ISO string: `2024-01-01T00:00:00Z`
  - Date string: `January 1, 2024`

**Response**:
```json
{
  "success": true,
  "iso": "2024-01-01T00:00:00.000Z",
  "unix": 1704067200,
  "unixMs": 1704067200000,
  "utc": "Mon, 01 Jan 2024 00:00:00 GMT",
  "local": "Mon Jan 01 2024 00:00:00 GMT+0000",
  "date": "1/1/2024",
  "time": "12:00:00 AM",
  "year": 2024,
  "month": 1,
  "day": 1,
  "dayOfWeek": "Monday"
}
```

---

### color-convert

Convert between color formats.

**URL**: `/run/color-convert?color={color}`

**Parameters**:
- `color` (required): Color in any supported format
  - Hex: `#RGB`, `#RRGGBB`, `#RRGGBBAA`
  - RGB: `rgb(255, 128, 0)`
  - RGBA: `rgba(255, 128, 0, 0.5)`

**Response**:
```json
{
  "success": true,
  "hex": "#ff8000",
  "hexAlpha": "#ff8000",
  "rgb": "rgb(255, 128, 0)",
  "rgba": "rgba(255, 128, 0, 1)",
  "hsl": "hsl(30, 100%, 50%)",
  "r": 255,
  "g": 128,
  "b": 0,
  "a": 1,
  "h": 30,
  "s": 100,
  "l": 50
}
```

---

## JavaScript SDK Reference

### Installation

```html
<script src="https://conveniencepro.cc/sdk/conveniencepro.js"></script>
```

Or for module bundlers:
```javascript
import ConveniencePro from 'https://conveniencepro.cc/sdk/conveniencepro.js';
```

### API

All methods follow the pattern:
```javascript
const result = ConveniencePro.methodName(param1, param2, ...);
// result.success === true/false
// result.error contains message if failed
```

### Methods

```javascript
// Encoding
ConveniencePro.base64Encode(text, urlSafe)
ConveniencePro.base64Decode(input)
ConveniencePro.urlEncode(text)
ConveniencePro.urlDecode(input)
ConveniencePro.htmlEncode(text)
ConveniencePro.htmlDecode(input)

// JSON
ConveniencePro.jsonFormat(json, indent)
ConveniencePro.jsonMinify(json)
ConveniencePro.jsonValidate(json)

// Hashing (async)
await ConveniencePro.hashSha256(text)
await ConveniencePro.hashSha512(text)
await ConveniencePro.hashSha1(text)
ConveniencePro.hashMd5(text)

// UUID
ConveniencePro.uuidGenerate(count)
ConveniencePro.uuidValidate(uuid)

// Regex
ConveniencePro.regexTest(pattern, text, flags)
ConveniencePro.regexReplace(pattern, text, replacement, flags)

// Text
ConveniencePro.textStats(text)
ConveniencePro.caseConvert(text, targetCase)
ConveniencePro.textReverse(text, mode)
ConveniencePro.textTrim(text, mode)

// Numbers
ConveniencePro.numberFormat(value, options)
ConveniencePro.numberBaseConvert(value, fromBase, toBase)

// Date/Time
ConveniencePro.timestampConvert(value)

// Colors
ConveniencePro.colorConvert(color)

// Utility
ConveniencePro.listTools() // Returns array of tool names
ConveniencePro.version     // SDK version string
```

---

## Embedding Guide

### Basic Iframe

```html
<iframe
  src="https://conveniencepro.cc/embed/base64-encode"
  width="400"
  height="300"
  style="border: none; border-radius: 8px;"
></iframe>
```

### Pre-filled Values

```html
<iframe
  src="https://conveniencepro.cc/embed/base64-encode?text=Hello"
  width="400"
  height="300"
></iframe>
```

### Receiving Results

```javascript
window.addEventListener('message', (event) => {
  if (event.origin !== 'https://conveniencepro.cc') return;

  if (event.data.type === 'conveniencepro-result') {
    console.log('Tool:', event.data.tool);
    console.log('Result:', event.data.result);
  }
});
```

---

## Security

### Data Privacy

- All processing happens in the user's browser
- No data is transmitted to ConveniencePro servers
- No logging, analytics, or tracking of tool inputs
- No cookies or local storage used for user data

### Architecture

- Static file deployment (HTML, JS, CSS, JSON)
- No server-side code execution
- No database or state management
- No authentication layer

### HTTPS

- All endpoints served over HTTPS
- Protects JavaScript integrity during delivery
- User data never traverses the network

---

## Links

- Website: https://conveniencepro.cc
- Tool Manifest: https://conveniencepro.cc/.well-known/ai-tools.json
- OpenAPI Spec: https://conveniencepro.cc/.well-known/openapi.yaml
- ChatGPT Plugin: https://conveniencepro.cc/.well-known/ai-plugin.json
- JavaScript SDK: https://conveniencepro.cc/sdk/conveniencepro.js
- LLM Summary: https://conveniencepro.cc/llms.txt