Build Skills for Nemo

import httpx
from typing import Any


async def crypto_price(symbol: str = "", **kwargs: Any) -> dict[str, Any]:
    """Get current price and 24h change for a cryptocurrency."""
    if not symbol:
        return {"error": "Please specify a crypto symbol (e.g. BTC, ETH)"}

    symbol = symbol.upper().strip()
    try:
        async with httpx.AsyncClient() as client:
            resp = await client.get(
                f"https://api.coingecko.com/api/v3/simple/price",
                params={
                    "ids": _SYMBOL_MAP.get(symbol, symbol.lower()),
                    "vs_currencies": "usd",
                    "include_24hr_change": "true",
                    "include_market_cap": "true",
                },
                timeout=10,
            )
            data = resp.json()
            coin_id = _SYMBOL_MAP.get(symbol, symbol.lower())
            if coin_id not in data:
                return {"error": f"Unknown symbol: {symbol}. Try BTC, ETH, SOL, etc."}
            info = data[coin_id]
            return {
                "symbol": symbol,
                "price_usd": info.get("usd"),
                "change_24h_pct": round(info.get("usd_24h_change", 0), 2),
                "market_cap_usd": info.get("usd_market_cap"),
            }
    except Exception as e:
        return {"error": f"Failed to fetch price: {e}"}


# Common symbol → CoinGecko ID mapping
_SYMBOL_MAP = {
    "BTC": "bitcoin", "ETH": "ethereum", "SOL": "solana",
    "ADA": "cardano", "DOGE": "dogecoin", "XRP": "ripple",
    "DOT": "polkadot", "AVAX": "avalanche-2",
}


TOOLS = {"crypto.price": crypto_price}

TOOL_SCHEMAS = [{
    "type": "function",
    "function": {
        "name": "crypto.price",
        "description": "Get current price and 24h change for a cryptocurrency by symbol.",
        "parameters": {
            "type": "object",
            "properties": {
                "symbol": {"type": "string", "description": "Crypto symbol (BTC, ETH, SOL, etc.)"}
            },
            "required": ["symbol"],
        },
    },
}]

CREDENTIAL_MAP = {}
SYSTEM_PROMPT = "You are a crypto price assistant. Use crypto.price to look up cryptocurrency prices."

import json
from datetime import datetime
from pathlib import Path
from typing import Any

_NOTES_FILE = Path.home() / ".nemo" / "notes.json"


def _load() -> list[dict]:
    if _NOTES_FILE.exists():
        return json.loads(_NOTES_FILE.read_text("utf-8"))
    return []


def _save(notes: list[dict]) -> None:
    _NOTES_FILE.parent.mkdir(parents=True, exist_ok=True)
    _NOTES_FILE.write_text(json.dumps(notes, indent=2), "utf-8")


async def notes_add(title: str = "", content: str = "", **kwargs) -> dict:
    """Save a new note."""
    if not content:
        return {"error": "Note content is required"}
    notes = _load()
    note = {
        "id": len(notes) + 1,
        "title": title or content[:50],
        "content": content,
        "created": datetime.now().isoformat(),
    }
    notes.append(note)
    _save(notes)
    return {"status": "ok", "note_id": note["id"], "title": note["title"]}


async def notes_list(query: str = "", **kwargs) -> dict:
    """List all notes, optionally filtered by search query."""
    notes = _load()
    if query:
        q = query.lower()
        notes = [n for n in notes if q in n["title"].lower() or q in n["content"].lower()]
    return {"status": "ok", "count": len(notes), "notes": notes[-20:]}


async def notes_delete(note_id: int = 0, **kwargs) -> dict:
    """Delete a note by ID."""
    notes = _load()
    notes = [n for n in notes if n["id"] != note_id]
    _save(notes)
    return {"status": "ok"}


TOOLS = {
    "notes.add": notes_add,
    "notes.list": notes_list,
    "notes.delete": notes_delete,
}

TOOL_SCHEMAS = [
    {"type": "function", "function": {
        "name": "notes.add",
        "description": "Save a new note with an optional title.",
        "parameters": {"type": "object", "properties": {
            "title": {"type": "string", "description": "Note title (auto-generated if empty)"},
            "content": {"type": "string", "description": "Note body text"},
        }, "required": ["content"]},
    }},
    {"type": "function", "function": {
        "name": "notes.list",
        "description": "List saved notes, optionally filtered by a search query.",
        "parameters": {"type": "object", "properties": {
            "query": {"type": "string", "description": "Search term to filter notes"},
        }},
    }},
    {"type": "function", "function": {
        "name": "notes.delete",
        "description": "Delete a note by its ID number.",
        "parameters": {"type": "object", "properties": {
            "note_id": {"type": "integer", "description": "ID of the note to delete"},
        }, "required": ["note_id"]},
    }},
]

CREDENTIAL_MAP = {}
SYSTEM_PROMPT = """You are a note-taking assistant. You have three tools:
- notes.add: Save a new note
- notes.list: Show saved notes (use query to search)
- notes.delete: Remove a note by ID
Always confirm what you saved or found."""

import httpx
from typing import Any


async def slack_send(
    channel: str = "",
    message: str = "",
    bot_token: str = "",  # Injected from vault via CREDENTIAL_MAP
    **kwargs: Any,
) -> dict[str, Any]:
    """Send a message to a Slack channel."""
    if not channel or not message:
        return {"error": "Both channel and message are required"}
    if not bot_token:
        return {"error": "Slack bot token not configured. Add it in Settings > Vault."}

    async with httpx.AsyncClient() as client:
        resp = await client.post(
            "https://slack.com/api/chat.postMessage",
            headers={"Authorization": f"Bearer {bot_token}"},
            json={"channel": channel, "text": message},
            timeout=10,
        )
        data = resp.json()
        if not data.get("ok"):
            return {"error": data.get("error", "Slack API error")}
        return {"status": "ok", "channel": channel, "ts": data.get("ts")}


TOOLS = {"slack.send": slack_send}

TOOL_SCHEMAS = [{
    "type": "function",
    "function": {
        "name": "slack.send",
        "description": "Send a message to a Slack channel.",
        "parameters": {
            "type": "object",
            "properties": {
                "channel": {"type": "string", "description": "Slack channel name or ID (e.g. #general)"},
                "message": {"type": "string", "description": "Message text to send"},
            },
            "required": ["channel", "message"],
        },
    },
}]

# bot_token is injected from vault — user stores it in Settings > Vault
CREDENTIAL_MAP = {
    "slack.*": {"bot_token": "credentials.slack.bot_token"},
}

SYSTEM_PROMPT = "You are a Slack messaging assistant. Use slack.send to post messages to channels."