Lettabot

node_modules
dist
.git
.env
.env.*
lettabot.yaml
lettabot.yml
lettabot-agent.json
data/
*.log
.skills/

# ============================================
# LettaBot Configuration
# ============================================

# Letta API Key (from app.letta.com)
LETTA_API_KEY=your_letta_api_key

# Working directory for agent workspace
# WORKING_DIR=/tmp/lettabot

# Persistent data directory override (agent store, cron jobs, logs)
# DATA_DIR=/absolute/path/to/lettabot-data

# Custom system prompt (optional)
# SYSTEM_PROMPT=You are a helpful assistant...

# Allowed tools (comma-separated)
# ALLOWED_TOOLS=Read,Glob,Grep,Task,web_search,conversation_search

# Disallowed tools (comma-separated)
# Default blocks plan-mode interactive tools that can stall headless agents
# DISALLOWED_TOOLS=EnterPlanMode,ExitPlanMode

# ============================================
# Telegram (required: at least one channel)
# ============================================
# Get token from @BotFather on Telegram
TELEGRAM_BOT_TOKEN=your_telegram_bot_token

# DM access policy: pairing (default), allowlist, open
# - pairing: Unknown senders get a code, must be approved via CLI
# - allowlist: Only users in TELEGRAM_ALLOWED_USERS can message
# - open: Anyone can message
# TELEGRAM_DM_POLICY=pairing

# Restrict to specific Telegram user IDs (comma-separated)
# Used when dmPolicy is 'allowlist', or as pre-approved users for 'pairing'
# TELEGRAM_ALLOWED_USERS=123456789,987654321

# ============================================
# Slack (optional)
# ============================================
# Get tokens from api.slack.com/apps
# Bot Token: xoxb-... (OAuth & Permissions)
# App Token: xapp-... (Socket Mode, enable in app settings)

# SLACK_BOT_TOKEN=xoxb-your-bot-token
# SLACK_APP_TOKEN=xapp-your-app-token

# Restrict to specific Slack user IDs (e.g., U01234567)
# SLACK_ALLOWED_USERS=U01234567,U98765432

# ============================================
# WhatsApp (optional)
# ============================================
# Enable WhatsApp (will show QR code on first run)
# WHATSAPP_ENABLED=true

# ============================================
# Signal (optional)
# ============================================
# Requires signal-cli: brew install signal-cli
# Link with: signal-cli link -n "LettaBot" (scan QR in Signal app)

# Your Signal phone number (E.164 format)
# SIGNAL_PHONE_NUMBER=+15551234567

# Path to signal-cli binary (default: signal-cli)
# SIGNAL_CLI_PATH=signal-cli

# HTTP daemon settings (default: 127.0.0.1:8090)
# SIGNAL_HTTP_HOST=127.0.0.1
# SIGNAL_HTTP_PORT=8090

# DM access policy: pairing (default), allowlist, open
# - pairing: Unknown senders get a code, must be approved via CLI
# - allowlist: Only users in SIGNAL_ALLOWED_USERS can message
# - open: Anyone can message
# SIGNAL_DM_POLICY=pairing

# Restrict to specific phone numbers (used with allowlist, or pre-approved for pairing)
# SIGNAL_ALLOWED_USERS=+15559876543,+15551112222

# Enable/disable Note to Self messages (default: true)
# SIGNAL_SELF_CHAT_MODE=true

# ============================================
# Polling (system-level background checks)
# ============================================
# Polls every minute by default for new emails, etc.
# POLLING_INTERVAL_MS=60000

# Gmail - requires gog CLI
# Install: brew install steipete/tap/gogcli
# Setup: gog auth add you@gmail.com --services gmail
# GMAIL_ACCOUNT=you@gmail.com

# Session storage path
# WHATSAPP_SESSION_PATH=./data/whatsapp-session

# Restrict to specific phone numbers (with country code)
# WHATSAPP_ALLOWED_USERS=+15551234567,+15559876543

# ============================================
# Cron Jobs (optional)
# ============================================
# Enable scheduled tasks
# CRON_ENABLED=true

# ============================================
# Memory Filesystem (optional)
# ============================================
# Enable memory filesystem (git-backed context repository)
# Syncs agent memory blocks to local files
# LETTABOT_MEMFS=true

# ============================================
# Heartbeat (optional)
# ============================================
# Explicit heartbeat toggle
# HEARTBEAT_ENABLED=true
#
# Heartbeat interval in minutes (set to enable heartbeat)
# Agent checks HEARTBEAT.md for tasks. Responds HEARTBEAT_OK if nothing to do.
# HEARTBEAT_INTERVAL_MIN=30

# Delivery target (format: channel:chatId). Defaults to last messaged chat.
# HEARTBEAT_TARGET=telegram:123456789

# Custom heartbeat prompt (optional)
# HEARTBEAT_PROMPT=Read HEARTBEAT.md if it exists. If nothing needs attention, reply HEARTBEAT_OK.

# ============================================
# Gmail Integration (optional)
# ============================================
# GMAIL_ENABLED=true
# GMAIL_WEBHOOK_PORT=8788
# GMAIL_WEBHOOK_TOKEN=your_webhook_secret
# GMAIL_CLIENT_ID=your_client_id.apps.googleusercontent.com
# GMAIL_CLIENT_SECRET=your_client_secret
# GMAIL_REFRESH_TOKEN=your_refresh_token
# GMAIL_TELEGRAM_USER=123456789

# ============================================
# Voice Memos / TTS (optional)
# ============================================
# TTS provider: "elevenlabs" (default) or "openai"
# TTS_PROVIDER=elevenlabs

# ElevenLabs (default provider)
# ELEVENLABS_API_KEY=sk_your_elevenlabs_key
# ELEVENLABS_VOICE_ID=21m00Tcm4TlvDq8ikWAM
# ELEVENLABS_MODEL_ID=eleven_multilingual_v2

# OpenAI TTS (uses OPENAI_API_KEY from above)
# OPENAI_TTS_VOICE=alloy
# OPENAI_TTS_MODEL=tts-1

# ============================================
# API Server (for Docker/CLI integration)
# ============================================
# API key for CLI authentication (auto-generated if not set)
# Check bot server logs on first run to see the generated key
# LETTABOT_API_KEY=your-secret-key-here

# API server URL (for CLI when bot runs in Docker)
# LETTABOT_API_URL=http://localhost:8080

# API server port (default: 8080)
# PORT=8080

# API server bind address (default: 127.0.0.1 for security)
# Use 0.0.0.0 in Docker to expose on all interfaces
# API_HOST=127.0.0.1

# CORS allowed origin (default: same-origin only)
# Use '*' to allow all origins (not recommended for production)
# API_CORS_ORIGIN=*

version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "daily"
    allow:
      - dependency-name: "@letta-ai/letta-code-sdk"
      - dependency-name: "@letta-ai/letta-client"
    labels:
      - "dependencies"
    commit-message:
      prefix: "chore(deps):"

name: Letta Code

on:
  issues:
    types: [opened, labeled]
  issue_comment:
    types: [created]
  pull_request:
    types: [opened, labeled]
  pull_request_review_comment:
    types: [created]

jobs:
  letta:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      issues: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      
      - uses: letta-ai/letta-code-action@v0
        with:
          letta_api_key: ${{ secrets.LETTA_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          # Use my persistent agent ID for consistent memory
          agent_id: agent-a7d61fda-62c3-44ae-90a0-c8359fae6e3d
          # Default to opus model for best quality
          model: opus
          # Trigger phrase
          trigger_phrase: "@letta-code"
          # Label trigger
          label_trigger: "letta-code"

name: Release

on:
  push:
    tags:
      - 'v*'

permissions:
  contents: write
  issues: write
  pull-requests: read

jobs:
  release:
    name: Create Release
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Full history for changelog generation

      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Lint runtime console usage
        run: npm run lint:console

      - name: Build
        run: npm run build

      - name: Run tests
        run: npm run test:run

      - name: Generate release notes
        id: notes
        run: |
          # Get the previous tag (if any)
          PREV_TAG=$(git tag --sort=-creatordate | sed -n '2p')
          CURRENT_TAG=${GITHUB_REF#refs/tags/}

          if [ -z "$PREV_TAG" ]; then
            echo "First release - including all commits"
            RANGE="HEAD"
          else
            RANGE="${PREV_TAG}..${CURRENT_TAG}"
          fi

          # Collect merged PRs from commit messages
          echo "## What's Changed" > notes.md
          echo "" >> notes.md

          # Extract PR numbers and titles from merge commits
          git log $RANGE --oneline --grep="(#" | while read -r line; do
            # Extract PR number
            PR_NUM=$(echo "$line" | grep -oP '\(#\K[0-9]+' | head -1)
            # Clean up the message (remove hash prefix)
            MSG=$(echo "$line" | sed 's/^[a-f0-9]* //')
            if [ -n "$PR_NUM" ]; then
              echo "- ${MSG} by @$(gh pr view $PR_NUM --json author --jq '.author.login' 2>/dev/null || echo 'contributor')" >> notes.md
            else
              echo "- ${MSG}" >> notes.md
            fi
          done

          # Add install instructions
          echo "" >> notes.md
          echo "## Install" >> notes.md
          echo "" >> notes.md
          echo '```bash' >> notes.md
          echo "npx lettabot onboard" >> notes.md
          echo "# or" >> notes.md
          echo "npm install -g lettabot" >> notes.md
          echo '```' >> notes.md

          # Add full changelog link
          if [ -n "$PREV_TAG" ]; then
            echo "" >> notes.md
            echo "**Full Changelog**: https://github.com/letta-ai/lettabot/compare/${PREV_TAG}...${CURRENT_TAG}" >> notes.md
          fi

          cat notes.md
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Create GitHub Release
        run: |
          CURRENT_TAG=${GITHUB_REF#refs/tags/}

          # Determine if pre-release
          if echo "$CURRENT_TAG" | grep -qE '(alpha|beta|rc)'; then
            PRERELEASE="--prerelease"
          else
            PRERELEASE=""
          fi

          gh release create "$CURRENT_TAG" \
            --title "$CURRENT_TAG" \
            --notes-file notes.md \
            $PRERELEASE
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Publish to npm
        if: env.NPM_TOKEN != ''
        run: |
          CURRENT_TAG=${GITHUB_REF#refs/tags/}
          echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc

          # Set version from git tag (strip 'v' prefix)
          VERSION=${CURRENT_TAG#v}
          npm version "$VERSION" --no-git-tag-version --allow-same-version

          # Determine npm tag (pre-releases get 'next', stable gets 'latest')
          if echo "$CURRENT_TAG" | grep -qE '(alpha|beta|rc)'; then
            npm publish --tag next --access public
          else
            npm publish --access public
          fi
        env:
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

name: Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  unit:
    name: Unit Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci

      - name: Lint runtime console usage
        run: npm run lint:console
      
      - name: Build
        run: npm run build
      
      - name: Run unit tests
        run: npm run test:run

  e2e:
    name: E2E Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci

      - name: Lint runtime console usage
        run: npm run lint:console
      
      - name: Build
        run: npm run build
      
      - name: Run e2e tests
        # Tests requiring secrets (bot.e2e, models.e2e) skip gracefully via describe.skipIf.
        # OpenAI SDK compat tests always run (no secrets needed, uses mock gateway).
        run: npm run test:e2e
        env:
          LETTA_API_KEY: ${{ secrets.LETTA_API_KEY }}
          LETTA_E2E_AGENT_ID: ${{ secrets.LETTA_E2E_AGENT_ID }}

  docker:
    name: Docker Build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build Docker image
        # Ensures Dockerfile build path stays healthy on main and PRs.
        run: docker build --tag lettabot:test .

# Dependencies
node_modules/

# Build output
dist/

# Environment files (contain secrets)
.env
.env.local

# Letta local data
.letta/

# User data
user-agents.json

# Reference repos (cloned for research)
*-reference/

# Test files
test-*.mjs
test-*.js

# OS files
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
.claude/

# Runtime files
cron-log.jsonl
cron-jobs.json
lettabot-agent.json
lettabot-agent.json.bak
lettabot-api.json
PERSONA.md
CLAUDE.md

# Related repos
moltbot/
letta-code-sdk/

# WhatsApp session (contains credentials)
data/whatsapp-session/

# Telegram MTProto session (contains authenticated session data)
data/telegram-mtproto/

# Config with secrets
lettabot.yaml
lettabot.yml

# Platform-specific deploy configs (generated by fly launch, etc.)
fly.toml
bun.lock
.tool-versions

# Telegram MTProto session data (contains auth secrets)
data/telegram-mtproto/
logs/

22

#!/usr/bin/env npx tsx
/**
 * Linear CLI for triage workflows
 * Usage: npx tsx linear.ts <command> [options]
 */

const LINEAR_API = "https://api.linear.app/graphql";
const API_KEY = process.env.LINEAR_API_KEY;

// Type definitions
interface GraphQLError {
  message: string;
}

interface WorkflowState {
  id: string;
  name: string;
}

interface IssueUpdateInput {
  priority?: number;
  stateId?: string;
}

if (!API_KEY) {
  console.error("Error: LINEAR_API_KEY environment variable not set");
  process.exit(1);
}

async function graphql(query: string, variables: Record<string, unknown> = {}) {
  const res = await fetch(LINEAR_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": API_KEY!,
    },
    body: JSON.stringify({ query, variables }),
  });
  const data = await res.json();
  if (data.errors) {
    throw new Error(data.errors.map((e: GraphQLError) => e.message).join(", "));
  }
  return data.data;
}

async function listIssues(filters: { state?: string; assignee?: string; limit?: number }) {
  const limit = filters.limit || 50;
  
  let filterStr = "";
  const filterParts: string[] = [];
  
  if (filters.state) {
    filterParts.push(`state: { name: { eq: "${filters.state}" } }`);
  }
  if (filters.assignee) {
    filterParts.push(`assignee: { name: { containsIgnoreCase: "${filters.assignee}" } }`);
  }
  
  if (filterParts.length > 0) {
    filterStr = `filter: { ${filterParts.join(", ")} }`;
  }

  const query = `
    query {
      issues(first: ${limit}, ${filterStr}) {
        nodes {
          id
          identifier
          title
          priority
          state { name }
          assignee { name }
          createdAt
          url
        }
      }
    }
  `;
  
  const data = await graphql(query);
  return data.issues.nodes;
}

async function getIssue(idOrIdentifier: string) {
  // Try by identifier first (e.g., "ENG-123")
  const query = `
    query($id: String!) {
      issue(id: $id) {
        id
        identifier
        title
        description
        priority
        state { name }
        assignee { name }
        labels { nodes { name } }
        createdAt
        updatedAt
        url
        comments {
          nodes {
            body
            user { name }
            createdAt
          }
        }
      }
    }
  `;
  
  try {
    const data = await graphql(query, { id: idOrIdentifier });
    return data.issue;
  } catch {
    // Try searching by identifier
    const searchQuery = `
      query($filter: IssueFilter) {
        issues(filter: $filter, first: 1) {
          nodes {
            id
            identifier
            title
            description
            priority
            state { name }
            assignee { name }
            labels { nodes { name } }
            createdAt
            updatedAt
            url
          }
        }
      }
    `;
    const data = await graphql(searchQuery, { 
      filter: { number: { eq: parseInt(idOrIdentifier.replace(/\D/g, "")) } }
    });
    return data.issues.nodes[0];
  }
}

async function updateIssue(id: string, updates: { priority?: number; state?: string }) {
  // First get the issue to find its ID
  const issue = await getIssue(id);
  if (!issue) {
    throw new Error(`Issue not found: ${id}`);
  }

  const input: IssueUpdateInput = {};
  
  if (updates.priority !== undefined) {
    input.priority = updates.priority;
  }
  
  if (updates.state) {
    // Need to find the state ID
    const statesQuery = `
      query {
        workflowStates {
          nodes {
            id
            name
          }
        }
      }
    `;
    const statesData = await graphql(statesQuery);
    const state = statesData.workflowStates.nodes.find(
      (s: WorkflowState) => s.name.toLowerCase() === updates.state!.toLowerCase()
    );
    if (!state) {
      throw new Error(`State not found: ${updates.state}`);
    }
    input.stateId = state.id;
  }

  const mutation = `
    mutation($id: String!, $input: IssueUpdateInput!) {
      issueUpdate(id: $id, input: $input) {
        issue {
          id
          identifier
          title
          priority
          state { name }
        }
      }
    }
  `;
  
  const data = await graphql(mutation, { id: issue.id, input });
  return data.issueUpdate.issue;
}

async function addComment(id: string, body: string) {
  const issue = await getIssue(id);
  if (!issue) {
    throw new Error(`Issue not found: ${id}`);
  }

  const mutation = `
    mutation($issueId: String!, $body: String!) {
      commentCreate(input: { issueId: $issueId, body: $body }) {
        comment {
          id
          body
          createdAt
        }
      }
    }
  `;
  
  const data = await graphql(mutation, { issueId: issue.id, body });
  return data.commentCreate.comment;
}

async function searchIssues(query: string) {
  const searchQuery = `
    query($query: String!) {
      searchIssues(query: $query, first: 20) {
        nodes {
          id
          identifier
          title
          priority
          state { name }
          assignee { name }
          url
        }
      }
    }
  `;
  
  const data = await graphql(searchQuery, { query });
  return data.searchIssues.nodes;
}

// CLI parsing
const args = process.argv.slice(2);
const command = args[0];

async function main() {
  try {
    switch (command) {
      case "list": {
        const filters: { state?: string; assignee?: string; limit?: number } = {};
        for (let i = 1; i < args.length; i++) {
          if (args[i] === "--state" && args[i + 1]) {
            filters.state = args[++i];
          } else if (args[i] === "--assignee" && args[i + 1]) {
            filters.assignee = args[++i];
          } else if (args[i] === "--limit" && args[i + 1]) {
            filters.limit = parseInt(args[++i]);
          }
        }
        const issues = await listIssues(filters);
        console.log(JSON.stringify(issues, null, 2));
        break;
      }
      
      case "get": {
        const id = args[1];
        if (!id) {
          console.error("Usage: get <issue-id>");
          process.exit(1);
        }
        const issue = await getIssue(id);
        console.log(JSON.stringify(issue, null, 2));
        break;
      }
      
      case "update": {
        const id = args[1];
        if (!id) {
          console.error("Usage: update <issue-id> [--priority N] [--state STATE]");
          process.exit(1);
        }
        const updates: { priority?: number; state?: string } = {};
        for (let i = 2; i < args.length; i++) {
          if (args[i] === "--priority" && args[i + 1]) {
            updates.priority = parseInt(args[++i]);
          } else if (args[i] === "--state" && args[i + 1]) {
            updates.state = args[++i];
          }
        }
        const issue = await updateIssue(id, updates);
        console.log(JSON.stringify(issue, null, 2));
        break;
      }
      
      case "comment": {
        const id = args[1];
        const body = args[2];
        if (!id || !body) {
          console.error("Usage: comment <issue-id> <body>");
          process.exit(1);
        }
        const comment = await addComment(id, body);
        console.log(JSON.stringify(comment, null, 2));
        break;
      }
      
      case "search": {
        const query = args.slice(1).join(" ");
        if (!query) {
          console.error("Usage: search <query>");
          process.exit(1);
        }
        const issues = await searchIssues(query);
        console.log(JSON.stringify(issues, null, 2));
        break;
      }
      
      default:
        console.log(`
Linear Triage CLI

Commands:
  list [--state STATE] [--assignee NAME] [--limit N]
  get <issue-id>
  update <issue-id> [--priority N] [--state STATE]
  comment <issue-id> <body>
  search <query>

Priority levels: 0=none, 1=urgent, 2=high, 3=medium, 4=low
        `);
    }
  } catch (error) {
    console.error("Error:", error instanceof Error ? error.message : error);
    process.exit(1);
  }
}

main();

[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"]

__all__ = ["__version__"]
__version__ = "0.1.0"

from __future__ import annotations

import logging
import os
from typing import Any

import httpx
from fastapi import HTTPException

from local_places.schemas import (
    LatLng,
    LocationResolveRequest,
    LocationResolveResponse,
    PlaceDetails,
    PlaceSummary,
    ResolvedLocation,
    SearchRequest,
    SearchResponse,
)

GOOGLE_PLACES_BASE_URL = os.getenv(
    "GOOGLE_PLACES_BASE_URL", "https://places.googleapis.com/v1"
)
logger = logging.getLogger("local_places.google_places")

_PRICE_LEVEL_TO_ENUM = {
    0: "PRICE_LEVEL_FREE",
    1: "PRICE_LEVEL_INEXPENSIVE",
    2: "PRICE_LEVEL_MODERATE",
    3: "PRICE_LEVEL_EXPENSIVE",
    4: "PRICE_LEVEL_VERY_EXPENSIVE",
}
_ENUM_TO_PRICE_LEVEL = {value: key for key, value in _PRICE_LEVEL_TO_ENUM.items()}

_SEARCH_FIELD_MASK = (
    "places.id,"
    "places.displayName,"
    "places.formattedAddress,"
    "places.location,"
    "places.rating,"
    "places.priceLevel,"
    "places.types,"
    "places.currentOpeningHours,"
    "nextPageToken"
)

_DETAILS_FIELD_MASK = (
    "id,"
    "displayName,"
    "formattedAddress,"
    "location,"
    "rating,"
    "priceLevel,"
    "types,"
    "regularOpeningHours,"
    "currentOpeningHours,"
    "nationalPhoneNumber,"
    "websiteUri"
)

_RESOLVE_FIELD_MASK = (
    "places.id,"
    "places.displayName,"
    "places.formattedAddress,"
    "places.location,"
    "places.types"
)


class _GoogleResponse:
    def __init__(self, response: httpx.Response):
        self.status_code = response.status_code
        self._response = response

    def json(self) -> dict[str, Any]:
        return self._response.json()

    @property
    def text(self) -> str:
        return self._response.text


def _api_headers(field_mask: str) -> dict[str, str]:
    api_key = os.getenv("GOOGLE_PLACES_API_KEY")
    if not api_key:
        raise HTTPException(
            status_code=500,
            detail="GOOGLE_PLACES_API_KEY is not set.",
        )
    return {
        "Content-Type": "application/json",
        "X-Goog-Api-Key": api_key,
        "X-Goog-FieldMask": field_mask,
    }


def _request(
    method: str, url: str, payload: dict[str, Any] | None, field_mask: str
) -> _GoogleResponse:
    try:
        with httpx.Client(timeout=10.0) as client:
            response = client.request(
                method=method,
                url=url,
                headers=_api_headers(field_mask),
                json=payload,
            )
    except httpx.HTTPError as exc:
        raise HTTPException(status_code=502, detail="Google Places API unavailable.") from exc

    return _GoogleResponse(response)


def _build_text_query(request: SearchRequest) -> str:
    keyword = request.filters.keyword if request.filters else None
    if keyword:
        return f"{request.query} {keyword}".strip()
    return request.query


def _build_search_body(request: SearchRequest) -> dict[str, Any]:
    body: dict[str, Any] = {
        "textQuery": _build_text_query(request),
        "pageSize": request.limit,
    }

    if request.page_token:
        body["pageToken"] = request.page_token

    if request.location_bias:
        body["locationBias"] = {
            "circle": {
                "center": {
                    "latitude": request.location_bias.lat,
                    "longitude": request.location_bias.lng,
                },
                "radius": request.location_bias.radius_m,
            }
        }

    if request.filters:
        filters = request.filters
        if filters.types:
            body["includedType"] = filters.types[0]
        if filters.open_now is not None:
            body["openNow"] = filters.open_now
        if filters.min_rating is not None:
            body["minRating"] = filters.min_rating
        if filters.price_levels:
            body["priceLevels"] = [
                _PRICE_LEVEL_TO_ENUM[level] for level in filters.price_levels
            ]

    return body


def _parse_lat_lng(raw: dict[str, Any] | None) -> LatLng | None:
    if not raw:
        return None
    latitude = raw.get("latitude")
    longitude = raw.get("longitude")
    if latitude is None or longitude is None:
        return None
    return LatLng(lat=latitude, lng=longitude)


def _parse_display_name(raw: dict[str, Any] | None) -> str | None:
    if not raw:
        return None
    return raw.get("text")


def _parse_open_now(raw: dict[str, Any] | None) -> bool | None:
    if not raw:
        return None
    return raw.get("openNow")


def _parse_hours(raw: dict[str, Any] | None) -> list[str] | None:
    if not raw:
        return None
    return raw.get("weekdayDescriptions")


def _parse_price_level(raw: str | None) -> int | None:
    if not raw:
        return None
    return _ENUM_TO_PRICE_LEVEL.get(raw)


def search_places(request: SearchRequest) -> SearchResponse:
    url = f"{GOOGLE_PLACES_BASE_URL}/places:searchText"
    response = _request("POST", url, _build_search_body(request), _SEARCH_FIELD_MASK)

    if response.status_code >= 400:
        logger.error(
            "Google Places API error %s. response=%s",
            response.status_code,
            response.text,
        )
        raise HTTPException(
            status_code=502,
            detail=f"Google Places API error ({response.status_code}).",
        )

    try:
        payload = response.json()
    except ValueError as exc:
        logger.error(
            "Google Places API returned invalid JSON. response=%s",
            response.text,
        )
        raise HTTPException(status_code=502, detail="Invalid Google response.") from exc

    places = payload.get("places", [])
    results = []
    for place in places:
        results.append(
            PlaceSummary(
                place_id=place.get("id", ""),
                name=_parse_display_name(place.get("displayName")),
                address=place.get("formattedAddress"),
                location=_parse_lat_lng(place.get("location")),
                rating=place.get("rating"),
                price_level=_parse_price_level(place.get("priceLevel")),
                types=place.get("types"),
                open_now=_parse_open_now(place.get("currentOpeningHours")),
            )
        )

    return SearchResponse(
        results=results,
        next_page_token=payload.get("nextPageToken"),
    )


def get_place_details(place_id: str) -> PlaceDetails:
    url = f"{GOOGLE_PLACES_BASE_URL}/places/{place_id}"
    response = _request("GET", url, None, _DETAILS_FIELD_MASK)

    if response.status_code >= 400:
        logger.error(
            "Google Places API error %s. response=%s",
            response.status_code,
            response.text,
        )
        raise HTTPException(
            status_code=502,
            detail=f"Google Places API error ({response.status_code}).",
        )

    try:
        payload = response.json()
    except ValueError as exc:
        logger.error(
            "Google Places API returned invalid JSON. response=%s",
            response.text,
        )
        raise HTTPException(status_code=502, detail="Invalid Google response.") from exc

    return PlaceDetails(
        place_id=payload.get("id", place_id),
        name=_parse_display_name(payload.get("displayName")),
        address=payload.get("formattedAddress"),
        location=_parse_lat_lng(payload.get("location")),
        rating=payload.get("rating"),
        price_level=_parse_price_level(payload.get("priceLevel")),
        types=payload.get("types"),
        phone=payload.get("nationalPhoneNumber"),
        website=payload.get("websiteUri"),
        hours=_parse_hours(payload.get("regularOpeningHours")),
        open_now=_parse_open_now(payload.get("currentOpeningHours")),
    )


def resolve_locations(request: LocationResolveRequest) -> LocationResolveResponse:
    url = f"{GOOGLE_PLACES_BASE_URL}/places:searchText"
    body = {"textQuery": request.location_text, "pageSize": request.limit}
    response = _request("POST", url, body, _RESOLVE_FIELD_MASK)

    if response.status_code >= 400:
        logger.error(
            "Google Places API error %s. response=%s",
            response.status_code,
            response.text,
        )
        raise HTTPException(
            status_code=502,
            detail=f"Google Places API error ({response.status_code}).",
        )

    try:
        payload = response.json()
    except ValueError as exc:
        logger.error(
            "Google Places API returned invalid JSON. response=%s",
            response.text,
        )
        raise HTTPException(status_code=502, detail="Invalid Google response.") from exc

    places = payload.get("places", [])
    results = []
    for place in places:
        results.append(
            ResolvedLocation(
                place_id=place.get("id", ""),
                name=_parse_display_name(place.get("displayName")),
                address=place.get("formattedAddress"),
                location=_parse_lat_lng(place.get("location")),
                types=place.get("types"),
            )
        )

    return LocationResolveResponse(results=results)

import logging
import os

from fastapi import FastAPI, Request
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

from local_places.google_places import get_place_details, resolve_locations, search_places
from local_places.schemas import (
    LocationResolveRequest,
    LocationResolveResponse,
    PlaceDetails,
    SearchRequest,
    SearchResponse,
)

app = FastAPI(
    title="My API",
    servers=[{"url": os.getenv("OPENAPI_SERVER_URL", "http://maxims-macbook-air:8000")}],
)
logger = logging.getLogger("local_places.validation")


@app.get("/ping")
def ping() -> dict[str, str]:
    return {"message": "pong"}


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(
    request: Request, exc: RequestValidationError
) -> JSONResponse:
    logger.error(
        "Validation error on %s %s. body=%s errors=%s",
        request.method,
        request.url.path,
        exc.body,
        exc.errors(),
    )
    return JSONResponse(
        status_code=422,
        content=jsonable_encoder({"detail": exc.errors()}),
    )


@app.post("/places/search", response_model=SearchResponse)
def places_search(request: SearchRequest) -> SearchResponse:
    return search_places(request)


@app.get("/places/{place_id}", response_model=PlaceDetails)
def places_details(place_id: str) -> PlaceDetails:
    return get_place_details(place_id)


@app.post("/locations/resolve", response_model=LocationResolveResponse)
def locations_resolve(request: LocationResolveRequest) -> LocationResolveResponse:
    return resolve_locations(request)


if __name__ == "__main__":
    import uvicorn

    uvicorn.run("local_places.main:app", host="0.0.0.0", port=8000)

from __future__ import annotations

from pydantic import BaseModel, Field, field_validator


class LatLng(BaseModel):
    lat: float = Field(ge=-90, le=90)
    lng: float = Field(ge=-180, le=180)


class LocationBias(BaseModel):
    lat: float = Field(ge=-90, le=90)
    lng: float = Field(ge=-180, le=180)
    radius_m: float = Field(gt=0)


class Filters(BaseModel):
    types: list[str] | None = None
    open_now: bool | None = None
    min_rating: float | None = Field(default=None, ge=0, le=5)
    price_levels: list[int] | None = None
    keyword: str | None = Field(default=None, min_length=1)

    @field_validator("types")
    @classmethod
    def validate_types(cls, value: list[str] | None) -> list[str] | None:
        if value is None:
            return value
        if len(value) > 1:
            raise ValueError(
                "Only one type is supported. Use query/keyword for additional filtering."
            )
        return value

    @field_validator("price_levels")
    @classmethod
    def validate_price_levels(cls, value: list[int] | None) -> list[int] | None:
        if value is None:
            return value
        invalid = [level for level in value if level not in range(0, 5)]
        if invalid:
            raise ValueError("price_levels must be integers between 0 and 4.")
        return value

    @field_validator("min_rating")
    @classmethod
    def validate_min_rating(cls, value: float | None) -> float | None:
        if value is None:
            return value
        if (value * 2) % 1 != 0:
            raise ValueError("min_rating must be in 0.5 increments.")
        return value


class SearchRequest(BaseModel):
    query: str = Field(min_length=1)
    location_bias: LocationBias | None = None
    filters: Filters | None = None
    limit: int = Field(default=10, ge=1, le=20)
    page_token: str | None = None


class PlaceSummary(BaseModel):
    place_id: str
    name: str | None = None
    address: str | None = None
    location: LatLng | None = None
    rating: float | None = None
    price_level: int | None = None
    types: list[str] | None = None
    open_now: bool | None = None


class SearchResponse(BaseModel):
    results: list[PlaceSummary]
    next_page_token: str | None = None


class LocationResolveRequest(BaseModel):
    location_text: str = Field(min_length=1)
    limit: int = Field(default=5, ge=1, le=10)


class ResolvedLocation(BaseModel):
    place_id: str
    name: str | None = None
    address: str | None = None
    location: LatLng | None = None
    types: list[str] | None = None


class LocationResolveResponse(BaseModel):
    results: list[ResolvedLocation]


class PlaceDetails(BaseModel):
    place_id: str
    name: str | None = None
    address: str | None = None
    location: LatLng | None = None
    rating: float | None = None
    price_level: int | None = None
    types: list[str] | None = None
    phone: str | None = None
    website: str | None = None
    hours: list[str] | None = None
    open_now: bool | None = None

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "google-genai>=1.0.0",
#     "pillow>=10.0.0",
# ]
# ///
"""
Generate images using Google's Nano Banana Pro (Gemini 3 Pro Image) API.

Usage:
    uv run generate_image.py --prompt "your image description" --filename "output.png" [--resolution 1K|2K|4K] [--api-key KEY]

Multi-image editing (up to 14 images):
    uv run generate_image.py --prompt "combine these images" --filename "output.png" -i img1.png -i img2.png -i img3.png
"""

import argparse
import os
import sys
from pathlib import Path


def get_api_key(provided_key: str | None) -> str | None:
    """Get API key from argument first, then environment."""
    if provided_key:
        return provided_key
    return os.environ.get("GEMINI_API_KEY")


def main():
    parser = argparse.ArgumentParser(
        description="Generate images using Nano Banana Pro (Gemini 3 Pro Image)"
    )
    parser.add_argument(
        "--prompt", "-p",
        required=True,
        help="Image description/prompt"
    )
    parser.add_argument(
        "--filename", "-f",
        required=True,
        help="Output filename (e.g., sunset-mountains.png)"
    )
    parser.add_argument(
        "--input-image", "-i",
        action="append",
        dest="input_images",
        metavar="IMAGE",
        help="Input image path(s) for editing/composition. Can be specified multiple times (up to 14 images)."
    )
    parser.add_argument(
        "--resolution", "-r",
        choices=["1K", "2K", "4K"],
        default="1K",
        help="Output resolution: 1K (default), 2K, or 4K"
    )
    parser.add_argument(
        "--api-key", "-k",
        help="Gemini API key (overrides GEMINI_API_KEY env var)"
    )

    args = parser.parse_args()

    # Get API key
    api_key = get_api_key(args.api_key)
    if not api_key:
        print("Error: No API key provided.", file=sys.stderr)
        print("Please either:", file=sys.stderr)
        print("  1. Provide --api-key argument", file=sys.stderr)
        print("  2. Set GEMINI_API_KEY environment variable", file=sys.stderr)
        sys.exit(1)

    # Import here after checking API key to avoid slow import on error
    from google import genai
    from google.genai import types
    from PIL import Image as PILImage

    # Initialise client
    client = genai.Client(api_key=api_key)

    # Set up output path
    output_path = Path(args.filename)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # Load input images if provided (up to 14 supported by Nano Banana Pro)
    input_images = []
    output_resolution = args.resolution
    if args.input_images:
        if len(args.input_images) > 14:
            print(f"Error: Too many input images ({len(args.input_images)}). Maximum is 14.", file=sys.stderr)
            sys.exit(1)

        max_input_dim = 0
        for img_path in args.input_images:
            try:
                img = PILImage.open(img_path)
                input_images.append(img)
                print(f"Loaded input image: {img_path}")

                # Track largest dimension for auto-resolution
                width, height = img.size
                max_input_dim = max(max_input_dim, width, height)
            except Exception as e:
                print(f"Error loading input image '{img_path}': {e}", file=sys.stderr)
                sys.exit(1)

        # Auto-detect resolution from largest input if not explicitly set
        if args.resolution == "1K" and max_input_dim > 0:  # Default value
            if max_input_dim >= 3000:
                output_resolution = "4K"
            elif max_input_dim >= 1500:
                output_resolution = "2K"
            else:
                output_resolution = "1K"
            print(f"Auto-detected resolution: {output_resolution} (from max input dimension {max_input_dim})")

    # Build contents (images first if editing, prompt only if generating)
    if input_images:
        contents = [*input_images, args.prompt]
        img_count = len(input_images)
        print(f"Processing {img_count} image{'s' if img_count > 1 else ''} with resolution {output_resolution}...")
    else:
        contents = args.prompt
        print(f"Generating image with resolution {output_resolution}...")

    try:
        response = client.models.generate_content(
            model="gemini-3-pro-image-preview",
            contents=contents,
            config=types.GenerateContentConfig(
                response_modalities=["TEXT", "IMAGE"],
                image_config=types.ImageConfig(
                    image_size=output_resolution
                )
            )
        )

        # Process response and convert to PNG
        image_saved = False
        for part in response.parts:
            if part.text is not None:
                print(f"Model response: {part.text}")
            elif part.inline_data is not None:
                # Convert inline data to PIL Image and save as PNG
                from io import BytesIO

                # inline_data.data is already bytes, not base64
                image_data = part.inline_data.data
                if isinstance(image_data, str):
                    # If it's a string, it might be base64
                    import base64
                    image_data = base64.b64decode(image_data)

                image = PILImage.open(BytesIO(image_data))

                # Ensure RGB mode for PNG (convert RGBA to RGB with white background if needed)
                if image.mode == 'RGBA':
                    rgb_image = PILImage.new('RGB', image.size, (255, 255, 255))
                    rgb_image.paste(image, mask=image.split()[3])
                    rgb_image.save(str(output_path), 'PNG')
                elif image.mode == 'RGB':
                    image.save(str(output_path), 'PNG')
                else:
                    image.convert('RGB').save(str(output_path), 'PNG')
                image_saved = True

        if image_saved:
            full_path = output_path.resolve()
            print(f"\nImage saved: {full_path}")
            # Clawdbot parses MEDIA tokens and will attach the file on supported providers.
            print(f"MEDIA: {full_path}")
        else:
            print("Error: No image was generated in the response.", file=sys.stderr)
            sys.exit(1)

    except Exception as e:
        print(f"Error generating image: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import base64
import datetime as dt
import json
import os
import random
import re
import sys
import urllib.error
import urllib.request
from pathlib import Path


def slugify(text: str) -> str:
    text = text.lower().strip()
    text = re.sub(r"[^a-z0-9]+", "-", text)
    text = re.sub(r"-{2,}", "-", text).strip("-")
    return text or "image"


def default_out_dir() -> Path:
    now = dt.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
    preferred = Path.home() / "Projects" / "tmp"
    base = preferred if preferred.is_dir() else Path("./tmp")
    base.mkdir(parents=True, exist_ok=True)
    return base / f"openai-image-gen-{now}"


def pick_prompts(count: int) -> list[str]:
    subjects = [
        "a lobster astronaut",
        "a brutalist lighthouse",
        "a cozy reading nook",
        "a cyberpunk noodle shop",
        "a Vienna street at dusk",
        "a minimalist product photo",
        "a surreal underwater library",
    ]
    styles = [
        "ultra-detailed studio photo",
        "35mm film still",
        "isometric illustration",
        "editorial photography",
        "soft watercolor",
        "architectural render",
        "high-contrast monochrome",
    ]
    lighting = [
        "golden hour",
        "overcast soft light",
        "neon lighting",
        "dramatic rim light",
        "candlelight",
        "foggy atmosphere",
    ]
    prompts: list[str] = []
    for _ in range(count):
        prompts.append(
            f"{random.choice(styles)} of {random.choice(subjects)}, {random.choice(lighting)}"
        )
    return prompts


def get_model_defaults(model: str) -> tuple[str, str]:
    """Return (default_size, default_quality) for the given model."""
    if model == "dall-e-2":
        # quality will be ignored
        return ("1024x1024", "standard")
    elif model == "dall-e-3":
        return ("1024x1024", "standard")
    else:
        # GPT image or future models
        return ("1024x1024", "high")


def request_images(
    api_key: str,
    prompt: str,
    model: str,
    size: str,
    quality: str,
    background: str = "",
    output_format: str = "",
    style: str = "",
) -> dict:
    url = "https://api.openai.com/v1/images/generations"
    args = {
        "model": model,
        "prompt": prompt,
        "size": size,
        "n": 1,
    }

    # Quality parameter - dall-e-2 doesn't accept this parameter
    if model != "dall-e-2":
        args["quality"] = quality

    # Note: response_format no longer supported by OpenAI Images API
    # dall-e models now return URLs by default

    if model.startswith("gpt-image"):
        if background:
            args["background"] = background
        if output_format:
            args["output_format"] = output_format

    if model == "dall-e-3" and style:
        args["style"] = style

    body = json.dumps(args).encode("utf-8")
    req = urllib.request.Request(
        url,
        method="POST",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        data=body,
    )
    try:
        with urllib.request.urlopen(req, timeout=300) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        payload = e.read().decode("utf-8", errors="replace")
        raise RuntimeError(f"OpenAI Images API failed ({e.code}): {payload}") from e


def write_gallery(out_dir: Path, items: list[dict]) -> None:
    thumbs = "\n".join(
        [
            f"""
<figure>
  <a href="{it["file"]}"><img src="{it["file"]}" loading="lazy" /></a>
  <figcaption>{it["prompt"]}</figcaption>
</figure>
""".strip()
            for it in items
        ]
    )
    html = f"""<!doctype html>
<meta charset="utf-8" />
<title>openai-image-gen</title>
<style>
  :root {{ color-scheme: dark; }}
  body {{ margin: 24px; font: 14px/1.4 ui-sans-serif, system-ui; background: #0b0f14; color: #e8edf2; }}
  h1 {{ font-size: 18px; margin: 0 0 16px; }}
  .grid {{ display: grid; grid-template-columns: repeat(auto-fill, minmax(240px, 1fr)); gap: 16px; }}
  figure {{ margin: 0; padding: 12px; border: 1px solid #1e2a36; border-radius: 14px; background: #0f1620; }}
  img {{ width: 100%; height: auto; border-radius: 10px; display: block; }}
  figcaption {{ margin-top: 10px; color: #b7c2cc; }}
  code {{ color: #9cd1ff; }}
</style>
<h1>openai-image-gen</h1>
<p>Output: <code>{out_dir.as_posix()}</code></p>
<div class="grid">
{thumbs}
</div>
"""
    (out_dir / "index.html").write_text(html, encoding="utf-8")


def main() -> int:
    ap = argparse.ArgumentParser(description="Generate images via OpenAI Images API.")
    ap.add_argument("--prompt", help="Single prompt. If omitted, random prompts are generated.")
    ap.add_argument("--count", type=int, default=8, help="How many images to generate.")
    ap.add_argument("--model", default="gpt-image-1", help="Image model id.")
    ap.add_argument("--size", default="", help="Image size (e.g. 1024x1024, 1536x1024). Defaults based on model if not specified.")
    ap.add_argument("--quality", default="", help="Image quality (e.g. high, standard). Defaults based on model if not specified.")
    ap.add_argument("--background", default="", help="Background transparency (GPT models only): transparent, opaque, or auto.")
    ap.add_argument("--output-format", default="", help="Output format (GPT models only): png, jpeg, or webp.")
    ap.add_argument("--style", default="", help="Image style (dall-e-3 only): vivid or natural.")
    ap.add_argument("--out-dir", default="", help="Output directory (default: ./tmp/openai-image-gen-<ts>).")
    args = ap.parse_args()

    api_key = (os.environ.get("OPENAI_API_KEY") or "").strip()
    if not api_key:
        print("Missing OPENAI_API_KEY", file=sys.stderr)
        return 2

    # Apply model-specific defaults if not specified
    default_size, default_quality = get_model_defaults(args.model)
    size = args.size or default_size
    quality = args.quality or default_quality

    count = args.count
    if args.model == "dall-e-3" and count > 1:
        print(f"Warning: dall-e-3 only supports generating 1 image at a time. Reducing count from {count} to 1.", file=sys.stderr)
        count = 1

    out_dir = Path(args.out_dir).expanduser() if args.out_dir else default_out_dir()
    out_dir.mkdir(parents=True, exist_ok=True)

    prompts = [args.prompt] * count if args.prompt else pick_prompts(count)

    # Determine file extension based on output format
    if args.model.startswith("gpt-image") and args.output_format:
        file_ext = args.output_format
    else:
        file_ext = "png"

    items: list[dict] = []
    for idx, prompt in enumerate(prompts, start=1):
        print(f"[{idx}/{len(prompts)}] {prompt}")
        res = request_images(
            api_key,
            prompt,
            args.model,
            size,
            quality,
            args.background,
            args.output_format,
            args.style,
        )
        data = res.get("data", [{}])[0]
        image_b64 = data.get("b64_json")
        image_url = data.get("url")
        if not image_b64 and not image_url:
            raise RuntimeError(f"Unexpected response: {json.dumps(res)[:400]}")

        filename = f"{idx:03d}-{slugify(prompt)[:40]}.{file_ext}"
        filepath = out_dir / filename
        if image_b64:
            filepath.write_bytes(base64.b64decode(image_b64))
        else:
            try:
                urllib.request.urlretrieve(image_url, filepath)
            except urllib.error.URLError as e:
                raise RuntimeError(f"Failed to download image from {image_url}: {e}") from e

        items.append({"prompt": prompt, "file": filename})

    (out_dir / "prompts.json").write_text(json.dumps(items, indent=2), encoding="utf-8")
    write_gallery(out_dir, items)
    print(f"\nWrote: {(out_dir / 'index.html').as_posix()}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat >&2 <<'EOF'
Usage:
  transcribe.sh <audio-file> [--model whisper-1] [--out /path/to/out.txt] [--language en] [--prompt "hint"] [--json]
EOF
  exit 2
}

if [[ "${1:-}" == "" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
  usage
fi

in="${1:-}"
shift || true

model="whisper-1"
out=""
language=""
prompt=""
response_format="text"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --model)
      model="${2:-}"
      shift 2
      ;;
    --out)
      out="${2:-}"
      shift 2
      ;;
    --language)
      language="${2:-}"
      shift 2
      ;;
    --prompt)
      prompt="${2:-}"
      shift 2
      ;;
    --json)
      response_format="json"
      shift 1
      ;;
    *)
      echo "Unknown arg: $1" >&2
      usage
      ;;
  esac
done

if [[ ! -f "$in" ]]; then
  echo "File not found: $in" >&2
  exit 1
fi

if [[ "${OPENAI_API_KEY:-}" == "" ]]; then
  echo "Missing OPENAI_API_KEY" >&2
  exit 1
fi

if [[ "$out" == "" ]]; then
  base="${in%.*}"
  if [[ "$response_format" == "json" ]]; then
    out="${base}.json"
  else
    out="${base}.txt"
  fi
fi

mkdir -p "$(dirname "$out")"

curl -sS https://api.openai.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Accept: application/json" \
  -F "file=@${in}" \
  -F "model=${model}" \
  -F "response_format=${response_format}" \
  ${language:+-F "language=${language}"} \
  ${prompt:+-F "prompt=${prompt}"} \
  >"$out"

echo "$out"

#!/usr/bin/env node

const fs = require("node:fs");
const path = require("node:path");
const { spawnSync } = require("node:child_process");

function usage(message) {
  if (message) {
    console.error(message);
  }
  console.error(
    "\nUsage: sherpa-onnx-tts [--runtime-dir <dir>] [--model-dir <dir>] [--model-file <file>] [--tokens-file <file>] [--data-dir <dir>] [--output <file>] \"text\"",
  );
  console.error("\nRequired env (or flags):\n  SHERPA_ONNX_RUNTIME_DIR\n  SHERPA_ONNX_MODEL_DIR");
  process.exit(1);
}

function resolveRuntimeDir(explicit) {
  const value = explicit || process.env.SHERPA_ONNX_RUNTIME_DIR || "";
  return value.trim();
}

function resolveModelDir(explicit) {
  const value = explicit || process.env.SHERPA_ONNX_MODEL_DIR || "";
  return value.trim();
}

function resolveModelFile(modelDir, explicitFlag) {
  const explicit = (explicitFlag || process.env.SHERPA_ONNX_MODEL_FILE || "").trim();
  if (explicit) return explicit;
  try {
    const candidates = fs
      .readdirSync(modelDir)
      .filter((entry) => entry.endsWith(".onnx"))
      .map((entry) => path.join(modelDir, entry));
    if (candidates.length === 1) return candidates[0];
  } catch {
    return "";
  }
  return "";
}

function resolveTokensFile(modelDir, explicitFlag) {
  const explicit = (explicitFlag || process.env.SHERPA_ONNX_TOKENS_FILE || "").trim();
  if (explicit) return explicit;
  const candidate = path.join(modelDir, "tokens.txt");
  return fs.existsSync(candidate) ? candidate : "";
}

function resolveDataDir(modelDir, explicitFlag) {
  const explicit = (explicitFlag || process.env.SHERPA_ONNX_DATA_DIR || "").trim();
  if (explicit) return explicit;
  const candidate = path.join(modelDir, "espeak-ng-data");
  return fs.existsSync(candidate) ? candidate : "";
}

function resolveBinary(runtimeDir) {
  const binName = process.platform === "win32" ? "sherpa-onnx-offline-tts.exe" : "sherpa-onnx-offline-tts";
  return path.join(runtimeDir, "bin", binName);
}

function prependEnvPath(current, next) {
  if (!next) return current;
  if (!current) return next;
  return `${next}${path.delimiter}${current}`;
}

const args = process.argv.slice(2);
let runtimeDir = "";
let modelDir = "";
let modelFile = "";
let tokensFile = "";
let dataDir = "";
let output = "tts.wav";
const textParts = [];

for (let i = 0; i < args.length; i += 1) {
  const arg = args[i];
  if (arg === "--runtime-dir") {
    runtimeDir = args[i + 1] || "";
    i += 1;
    continue;
  }
  if (arg === "--model-dir") {
    modelDir = args[i + 1] || "";
    i += 1;
    continue;
  }
  if (arg === "--model-file") {
    modelFile = args[i + 1] || "";
    i += 1;
    continue;
  }
  if (arg === "--tokens-file") {
    tokensFile = args[i + 1] || "";
    i += 1;
    continue;
  }
  if (arg === "--data-dir") {
    dataDir = args[i + 1] || "";
    i += 1;
    continue;
  }
  if (arg === "-o" || arg === "--output") {
    output = args[i + 1] || output;
    i += 1;
    continue;
  }
  if (arg === "--text") {
    textParts.push(args[i + 1] || "");
    i += 1;
    continue;
  }
  textParts.push(arg);
}

runtimeDir = resolveRuntimeDir(runtimeDir);
modelDir = resolveModelDir(modelDir);

if (!runtimeDir || !modelDir) {
  usage("Missing runtime/model directory.");
}

modelFile = resolveModelFile(modelDir, modelFile);
tokensFile = resolveTokensFile(modelDir, tokensFile);
dataDir = resolveDataDir(modelDir, dataDir);

if (!modelFile || !tokensFile || !dataDir) {
  usage(
    "Model directory is missing required files. Set SHERPA_ONNX_MODEL_FILE, SHERPA_ONNX_TOKENS_FILE, SHERPA_ONNX_DATA_DIR or pass --model-file/--tokens-file/--data-dir.",
  );
}

const text = textParts.join(" ").trim();
if (!text) {
  usage("Missing text.");
}

const bin = resolveBinary(runtimeDir);
if (!fs.existsSync(bin)) {
  usage(`TTS binary not found: ${bin}`);
}

const env = { ...process.env };
const libDir = path.join(runtimeDir, "lib");
if (process.platform === "darwin") {
  env.DYLD_LIBRARY_PATH = prependEnvPath(env.DYLD_LIBRARY_PATH || "", libDir);
} else if (process.platform === "win32") {
  env.PATH = prependEnvPath(env.PATH || "", [path.join(runtimeDir, "bin"), libDir].join(path.delimiter));
} else {
  env.LD_LIBRARY_PATH = prependEnvPath(env.LD_LIBRARY_PATH || "", libDir);
}

const outputPath = path.isAbsolute(output) ? output : path.join(process.cwd(), output);
fs.mkdirSync(path.dirname(outputPath), { recursive: true });

const child = spawnSync(
  bin,
  [
    `--vits-model=${modelFile}`,
    `--vits-tokens=${tokensFile}`,
    `--vits-data-dir=${dataDir}`,
    `--output-filename=${outputPath}`,
    text,
  ],
  {
    stdio: "inherit",
    env,
  },
);

if (typeof child.status === "number") {
  process.exit(child.status);
}
if (child.error) {
  console.error(child.error.message || String(child.error));
}
process.exit(1);

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'USAGE'
Usage: find-sessions.sh [-L socket-name|-S socket-path|-A] [-q pattern]

List tmux sessions on a socket (default tmux socket if none provided).

Options:
  -L, --socket       tmux socket name (passed to tmux -L)
  -S, --socket-path  tmux socket path (passed to tmux -S)
  -A, --all          scan all sockets under CLAWDBOT_TMUX_SOCKET_DIR
  -q, --query        case-insensitive substring to filter session names
  -h, --help         show this help
USAGE
}

socket_name=""
socket_path=""
query=""
scan_all=false
socket_dir="${CLAWDBOT_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/clawdbot-tmux-sockets}"

while [[ $# -gt 0 ]]; do
  case "$1" in
    -L|--socket)      socket_name="${2-}"; shift 2 ;;
    -S|--socket-path) socket_path="${2-}"; shift 2 ;;
    -A|--all)         scan_all=true; shift ;;
    -q|--query)       query="${2-}"; shift 2 ;;
    -h|--help)        usage; exit 0 ;;
    *) echo "Unknown option: $1" >&2; usage; exit 1 ;;
  esac
done

if [[ "$scan_all" == true && ( -n "$socket_name" || -n "$socket_path" ) ]]; then
  echo "Cannot combine --all with -L or -S" >&2
  exit 1
fi

if [[ -n "$socket_name" && -n "$socket_path" ]]; then
  echo "Use either -L or -S, not both" >&2
  exit 1
fi

if ! command -v tmux >/dev/null 2>&1; then
  echo "tmux not found in PATH" >&2
  exit 1
fi

list_sessions() {
  local label="$1"; shift
  local tmux_cmd=(tmux "$@")

  if ! sessions="$("${tmux_cmd[@]}" list-sessions -F '#{session_name}\t#{session_attached}\t#{session_created_string}' 2>/dev/null)"; then
    echo "No tmux server found on $label" >&2
    return 1
  fi

  if [[ -n "$query" ]]; then
    sessions="$(printf '%s\n' "$sessions" | grep -i -- "$query" || true)"
  fi

  if [[ -z "$sessions" ]]; then
    echo "No sessions found on $label"
    return 0
  fi

  echo "Sessions on $label:"
  printf '%s\n' "$sessions" | while IFS=$'\t' read -r name attached created; do
    attached_label=$([[ "$attached" == "1" ]] && echo "attached" || echo "detached")
    printf '  - %s (%s, started %s)\n' "$name" "$attached_label" "$created"
  done
}

if [[ "$scan_all" == true ]]; then
  if [[ ! -d "$socket_dir" ]]; then
    echo "Socket directory not found: $socket_dir" >&2
    exit 1
  fi

  shopt -s nullglob
  sockets=("$socket_dir"/*)
  shopt -u nullglob

  if [[ "${#sockets[@]}" -eq 0 ]]; then
    echo "No sockets found under $socket_dir" >&2
    exit 1
  fi

  exit_code=0
  for sock in "${sockets[@]}"; do
    if [[ ! -S "$sock" ]]; then
      continue
    fi
    list_sessions "socket path '$sock'" -S "$sock" || exit_code=$?
  done
  exit "$exit_code"
fi

tmux_cmd=(tmux)
socket_label="default socket"

if [[ -n "$socket_name" ]]; then
  tmux_cmd+=(-L "$socket_name")
  socket_label="socket name '$socket_name'"
elif [[ -n "$socket_path" ]]; then
  tmux_cmd+=(-S "$socket_path")
  socket_label="socket path '$socket_path'"
fi

list_sessions "$socket_label" "${tmux_cmd[@]:1}"