@elizaos/skills 2.0.0-alpha.43 → 2.0.0-alpha.430

package/skills/himalaya/references/configuration.md

@@ -1,184 +0,0 @@
-# Himalaya Configuration Reference
-
-Configuration file location: `~/.config/himalaya/config.toml`
-
-## Minimal IMAP + SMTP Setup
-
-```toml
-[accounts.default]
-email = "user@example.com"
-display-name = "Your Name"
-default = true
-
-# IMAP backend for reading emails
-backend.type = "imap"
-backend.host = "imap.example.com"
-backend.port = 993
-backend.encryption.type = "tls"
-backend.login = "user@example.com"
-backend.auth.type = "password"
-backend.auth.raw = "your-password"
-
-# SMTP backend for sending emails
-message.send.backend.type = "smtp"
-message.send.backend.host = "smtp.example.com"
-message.send.backend.port = 587
-message.send.backend.encryption.type = "start-tls"
-message.send.backend.login = "user@example.com"
-message.send.backend.auth.type = "password"
-message.send.backend.auth.raw = "your-password"
-```
-
-## Password Options
-
-### Raw password (testing only, not recommended)
-
-```toml
-backend.auth.raw = "your-password"
-```
-
-### Password from command (recommended)
-
-```toml
-backend.auth.cmd = "pass show email/imap"
-# backend.auth.cmd = "security find-generic-password -a user@example.com -s imap -w"
-```
-
-### System keyring (requires keyring feature)
-
-```toml
-backend.auth.keyring = "imap-example"
-```
-
-Then run `himalaya account configure <account>` to store the password.
-
-## Gmail Configuration
-
-```toml
-[accounts.gmail]
-email = "you@gmail.com"
-display-name = "Your Name"
-default = true
-
-backend.type = "imap"
-backend.host = "imap.gmail.com"
-backend.port = 993
-backend.encryption.type = "tls"
-backend.login = "you@gmail.com"
-backend.auth.type = "password"
-backend.auth.cmd = "pass show google/app-password"
-
-message.send.backend.type = "smtp"
-message.send.backend.host = "smtp.gmail.com"
-message.send.backend.port = 587
-message.send.backend.encryption.type = "start-tls"
-message.send.backend.login = "you@gmail.com"
-message.send.backend.auth.type = "password"
-message.send.backend.auth.cmd = "pass show google/app-password"
-```
-
-**Note:** Gmail requires an App Password if 2FA is enabled.
-
-## iCloud Configuration
-
-```toml
-[accounts.icloud]
-email = "you@icloud.com"
-display-name = "Your Name"
-
-backend.type = "imap"
-backend.host = "imap.mail.me.com"
-backend.port = 993
-backend.encryption.type = "tls"
-backend.login = "you@icloud.com"
-backend.auth.type = "password"
-backend.auth.cmd = "pass show icloud/app-password"
-
-message.send.backend.type = "smtp"
-message.send.backend.host = "smtp.mail.me.com"
-message.send.backend.port = 587
-message.send.backend.encryption.type = "start-tls"
-message.send.backend.login = "you@icloud.com"
-message.send.backend.auth.type = "password"
-message.send.backend.auth.cmd = "pass show icloud/app-password"
-```
-
-**Note:** Generate an app-specific password at appleid.apple.com
-
-## Folder Aliases
-
-Map custom folder names:
-
-```toml
-[accounts.default.folder.alias]
-inbox = "INBOX"
-sent = "Sent"
-drafts = "Drafts"
-trash = "Trash"
-```
-
-## Multiple Accounts
-
-```toml
-[accounts.personal]
-email = "personal@example.com"
-default = true
-# ... backend config ...
-
-[accounts.work]
-email = "work@company.com"
-# ... backend config ...
-```
-
-Switch accounts with `--account`:
-
-```bash
-himalaya --account work envelope list
-```
-
-## Notmuch Backend (local mail)
-
-```toml
-[accounts.local]
-email = "user@example.com"
-
-backend.type = "notmuch"
-backend.db-path = "~/.mail/.notmuch"
-```
-
-## OAuth2 Authentication (for providers that support it)
-
-```toml
-backend.auth.type = "oauth2"
-backend.auth.client-id = "your-client-id"
-backend.auth.client-secret.cmd = "pass show oauth/client-secret"
-backend.auth.access-token.cmd = "pass show oauth/access-token"
-backend.auth.refresh-token.cmd = "pass show oauth/refresh-token"
-backend.auth.auth-url = "https://provider.com/oauth/authorize"
-backend.auth.token-url = "https://provider.com/oauth/token"
-```
-
-## Additional Options
-
-### Signature
-
-```toml
-[accounts.default]
-signature = "Best regards,\nYour Name"
-signature-delim = "-- \n"
-```
-
-### Downloads directory
-
-```toml
-[accounts.default]
-downloads-dir = "~/Downloads/himalaya"
-```
-
-### Editor for composing
-
-Set via environment variable:
-
-```bash
-export EDITOR="vim"
-```

package/skills/himalaya/references/message-composition.md

@@ -1,199 +0,0 @@
-# Message Composition with MML (MIME Meta Language)
-
-Himalaya uses MML for composing emails. MML is a simple XML-based syntax that compiles to MIME messages.
-
-## Basic Message Structure
-
-An email message is a list of **headers** followed by a **body**, separated by a blank line:
-
-```
-From: sender@example.com
-To: recipient@example.com
-Subject: Hello World
-
-This is the message body.
-```
-
-## Headers
-
-Common headers:
-
-- `From`: Sender address
-- `To`: Primary recipient(s)
-- `Cc`: Carbon copy recipients
-- `Bcc`: Blind carbon copy recipients
-- `Subject`: Message subject
-- `Reply-To`: Address for replies (if different from From)
-- `In-Reply-To`: Message ID being replied to
-
-### Address Formats
-
-```
-To: user@example.com
-To: John Doe <john@example.com>
-To: "John Doe" <john@example.com>
-To: user1@example.com, user2@example.com, "Jane" <jane@example.com>
-```
-
-## Plain Text Body
-
-Simple plain text email:
-
-```
-From: alice@localhost
-To: bob@localhost
-Subject: Plain Text Example
-
-Hello, this is a plain text email.
-No special formatting needed.
-
-Best,
-Alice
-```
-
-## MML for Rich Emails
-
-### Multipart Messages
-
-Alternative text/html parts:
-
-```
-From: alice@localhost
-To: bob@localhost
-Subject: Multipart Example
-
-<#multipart type=alternative>
-This is the plain text version.
-<#part type=text/html>
-<html><body><h1>This is the HTML version</h1></body></html>
-<#/multipart>
-```
-
-### Attachments
-
-Attach a file:
-
-```
-From: alice@localhost
-To: bob@localhost
-Subject: With Attachment
-
-Here is the document you requested.
-
-<#part filename=/path/to/document.pdf><#/part>
-```
-
-Attachment with custom name:
-
-```
-<#part filename=/path/to/file.pdf name=report.pdf><#/part>
-```
-
-Multiple attachments:
-
-```
-<#part filename=/path/to/doc1.pdf><#/part>
-<#part filename=/path/to/doc2.pdf><#/part>
-```
-
-### Inline Images
-
-Embed an image inline:
-
-```
-From: alice@localhost
-To: bob@localhost
-Subject: Inline Image
-
-<#multipart type=related>
-<#part type=text/html>
-<html><body>
-<p>Check out this image:</p>
-<img src="cid:image1">
-</body></html>
-<#part disposition=inline id=image1 filename=/path/to/image.png><#/part>
-<#/multipart>
-```
-
-### Mixed Content (Text + Attachments)
-
-```
-From: alice@localhost
-To: bob@localhost
-Subject: Mixed Content
-
-<#multipart type=mixed>
-<#part type=text/plain>
-Please find the attached files.
-
-Best,
-Alice
-<#part filename=/path/to/file1.pdf><#/part>
-<#part filename=/path/to/file2.zip><#/part>
-<#/multipart>
-```
-
-## MML Tag Reference
-
-### `<#multipart>`
-
-Groups multiple parts together.
-
-- `type=alternative`: Different representations of same content
-- `type=mixed`: Independent parts (text + attachments)
-- `type=related`: Parts that reference each other (HTML + images)
-
-### `<#part>`
-
-Defines a message part.
-
-- `type=<mime-type>`: Content type (e.g., `text/html`, `application/pdf`)
-- `filename=<path>`: File to attach
-- `name=<name>`: Display name for attachment
-- `disposition=inline`: Display inline instead of as attachment
-- `id=<cid>`: Content ID for referencing in HTML
-
-## Composing from CLI
-
-### Interactive compose
-
-Opens your `$EDITOR`:
-
-```bash
-himalaya message write
-```
-
-### Reply (opens editor with quoted message)
-
-```bash
-himalaya message reply 42
-himalaya message reply 42 --all  # reply-all
-```
-
-### Forward
-
-```bash
-himalaya message forward 42
-```
-
-### Send from stdin
-
-```bash
-cat message.txt | himalaya template send
-```
-
-### Prefill headers from CLI
-
-```bash
-himalaya message write \
-  -H "To:recipient@example.com" \
-  -H "Subject:Quick Message" \
-  "Message body here"
-```
-
-## Tips
-
-- The editor opens with a template; fill in headers and body.
-- Save and exit the editor to send; exit without saving to cancel.
-- MML parts are compiled to proper MIME when sending.
-- Use `himalaya message export --full` to inspect the raw MIME structure of received emails.

package/skills/local-places/SERVER_README.md

@@ -1,101 +0,0 @@
-# Local Places
-
-This repo is a fusion of two pieces:
-
-- A FastAPI server that exposes endpoints for searching and resolving places via the Google Maps Places API.
-- A companion agent skill that explains how to use the API and can call it to find places efficiently.
-
-Together, the skill and server let an agent turn natural-language place queries into structured results quickly.
-
-## Run locally
-
-```bash
-# copy skill definition into the relevant folder (where the agent looks for it)
-# then run the server
-
-uv venv
-uv pip install -e ".[dev]"
-uv run --env-file .env uvicorn local_places.main:app --host 0.0.0.0 --reload
-```
-
-Open the API docs at http://127.0.0.1:8000/docs.
-
-## Places API
-
-Set the Google Places API key before running:
-
-```bash
-export GOOGLE_PLACES_API_KEY="your-key"
-```
-
-Endpoints:
-
-- `POST /places/search` (free-text query + filters)
-- `GET /places/{place_id}` (place details)
-- `POST /locations/resolve` (resolve a user-provided location string)
-
-Example search request:
-
-```json
-{
-  "query": "italian restaurant",
-  "filters": {
-    "types": ["restaurant"],
-    "open_now": true,
-    "min_rating": 4.0,
-    "price_levels": [1, 2]
-  },
-  "limit": 10
-}
-```
-
-Notes:
-
-- `filters.types` supports a single type (mapped to Google `includedType`).
-
-Example search request (curl):
-
-```bash
-curl -X POST http://127.0.0.1:8000/places/search \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "italian restaurant",
-    "location_bias": {
-      "lat": 40.8065,
-      "lng": -73.9719,
-      "radius_m": 3000
-    },
-    "filters": {
-      "types": ["restaurant"],
-      "open_now": true,
-      "min_rating": 4.0,
-      "price_levels": [1, 2, 3]
-    },
-    "limit": 10
-  }'
-```
-
-Example resolve request (curl):
-
-```bash
-curl -X POST http://127.0.0.1:8000/locations/resolve \
-  -H "Content-Type: application/json" \
-  -d '{
-    "location_text": "Riverside Park, New York",
-    "limit": 5
-  }'
-```
-
-## Test
-
-```bash
-uv run pytest
-```
-
-## OpenAPI
-
-Generate the OpenAPI schema:
-
-```bash
-uv run python scripts/generate_openapi.py
-```

package/skills/local-places/SKILL.md

@@ -1,102 +0,0 @@
----
-name: local-places
-description: Search for places (restaurants, cafes, etc.) via Google Places API proxy on localhost.
-homepage: https://github.com/Hyaxia/local_places
-metadata:
-  {
-    "otto":
-      {
-        "emoji": "📍",
-        "requires": { "bins": ["uv"], "env": ["GOOGLE_PLACES_API_KEY"] },
-        "primaryEnv": "GOOGLE_PLACES_API_KEY",
-      },
-  }
----
-
-# 📍 Local Places
-
-_Find places, Go fast_
-
-Search for nearby places using a local Google Places API proxy. Two-step flow: resolve location first, then search.
-
-## Setup
-
-```bash
-cd {baseDir}
-echo "GOOGLE_PLACES_API_KEY=your-key" > .env
-uv venv && uv pip install -e ".[dev]"
-uv run --env-file .env uvicorn local_places.main:app --host 127.0.0.1 --port 8000
-```
-
-Requires `GOOGLE_PLACES_API_KEY` in `.env` or environment.
-
-## Quick Start
-
-1. **Check server:** `curl http://127.0.0.1:8000/ping`
-
-2. **Resolve location:**
-
-```bash
-curl -X POST http://127.0.0.1:8000/locations/resolve \
-  -H "Content-Type: application/json" \
-  -d '{"location_text": "Soho, London", "limit": 5}'
-```
-
-3. **Search places:**
-
-```bash
-curl -X POST http://127.0.0.1:8000/places/search \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "coffee shop",
-    "location_bias": {"lat": 51.5137, "lng": -0.1366, "radius_m": 1000},
-    "filters": {"open_now": true, "min_rating": 4.0},
-    "limit": 10
-  }'
-```
-
-4. **Get details:**
-
-```bash
-curl http://127.0.0.1:8000/places/{place_id}
-```
-
-## Conversation Flow
-
-1. If user says "near me" or gives vague location → resolve it first
-2. If multiple results → show numbered list, ask user to pick
-3. Ask for preferences: type, open now, rating, price level
-4. Search with `location_bias` from chosen location
-5. Present results with name, rating, address, open status
-6. Offer to fetch details or refine search
-
-## Filter Constraints
-
-- `filters.types`: exactly ONE type (e.g., "restaurant", "cafe", "gym")
-- `filters.price_levels`: integers 0-4 (0=free, 4=very expensive)
-- `filters.min_rating`: 0-5 in 0.5 increments
-- `filters.open_now`: boolean
-- `limit`: 1-20 for search, 1-10 for resolve
-- `location_bias.radius_m`: must be > 0
-
-## Response Format
-
-```json
-{
-  "results": [
-    {
-      "place_id": "ChIJ...",
-      "name": "Coffee Shop",
-      "address": "123 Main St",
-      "location": { "lat": 51.5, "lng": -0.1 },
-      "rating": 4.6,
-      "price_level": 2,
-      "types": ["cafe", "food"],
-      "open_now": true
-    }
-  ],
-  "next_page_token": "..."
-}
-```
-
-Use `next_page_token` as `page_token` in next request for more results.

package/skills/local-places/pyproject.toml

@@ -1,21 +0,0 @@
-[project]
-name = "my-api"
-version = "0.1.0"
-description = "FastAPI server"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = ["fastapi>=0.110.0", "httpx>=0.27.0", "uvicorn[standard]>=0.29.0"]
-
-[project.optional-dependencies]
-dev = ["pytest>=8.0.0"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/local_places"]
-
-[tool.pytest.ini_options]
-addopts = "-q"
-testpaths = ["tests"]

package/skills/local-places/src/local_places/__init__.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "0.1.0"