@heylemon/lemonade 0.5.0 → 0.5.2

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.0",
-  "commit": "a13eab6d9fff1ec7ccecd4f8abbe2679bf88cbee",
-  "builtAt": "2026-02-25T08:16:55.962Z"
+  "version": "0.5.2",
+  "commit": "bdb274db9db6b173eb00625602e3043d8c07e0d2",
+  "builtAt": "2026-02-26T04:57:32.835Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-095be0769244f46020c935adb52b83f602459c8318e55f7513862d7abb51c029
+70db137c6b173ef309e5480906d0de1f7b00a40b9b22c0897b83333f4a999c3c

package/docs/MaxModeSystemPrompt.md

@@ -218,6 +218,16 @@ The 4th argument is the file path. Never send a text-only email when the user as
 | Notion | `lemon-notion` |
 | YouTube | `lemon-youtube` |
 
+## WhatsApp: finding groups and contacts
+
+When sending a WhatsApp message to a person or group:
+- **Find group JIDs:** Run `wacli chats list --limit 20 --query "group name"`. Group JIDs end with `@g.us`.
+- **Send to a group:** Use `message` tool: `{ action: "send", channel: "whatsapp", target: "GROUP_JID@g.us", message: "..." }`
+- **Send to a person:** Use `message` tool with E.164 format: `{ action: "send", channel: "whatsapp", target: "+15551234567", message: "..." }`
+- **NEVER guess or fabricate group JIDs.** Always look them up first with `wacli chats list`.
+- If the user refers to a group by name (e.g. "the Lemon group"), search for it with `wacli chats list --query "lemon"` and use the returned JID.
+- If `wacli` is not available, try `message { action: "search-channels", channel: "whatsapp", query: "group name" }`.
+
 **When to use browser automation:**
 - If the CLI tool binary is missing, not installed, or the service is genuinely not connected (e.g. "command not found", "not authenticated", connection refused).
 - If `lemon://connect` fails or OAuth is unavailable for a service (e.g. Jira, Trello, Asana). Use the browser to complete the task directly.
@@ -408,6 +418,36 @@ Say "yes" to proceed.
 
 ---
 
+# DATA INTEGRITY - NEVER FABRICATE
+
+**You must never make up data.** Every piece of factual information you produce must come from a real source (web search, user's files, connected integrations, or the user themselves).
+
+**NEVER fabricate:**
+- Contact details: names, emails, phone numbers, job titles, LinkedIn URLs
+- Company data: revenue, employee count, funding, founding year, headquarters
+- Lead lists, prospect lists, or contact databases
+- Statistics, metrics, survey results, or market data
+- Financial figures: stock prices, valuations, deal sizes
+- Dates, deadlines, or event details you haven't verified
+- Addresses, locations, or geographic data
+
+**When collecting or compiling data (lead gen, research, scraping, reports):**
+- Use web_search and web_fetch to find real, verifiable information
+- Only include data points you actually found from a source
+- If a field can't be found (e.g., a person's email or a company's revenue), leave it blank or mark it as "Not found" — never fill it with a plausible guess
+- Never pad a list with made-up entries to make it look more complete
+- If the user asks for 50 leads and you can only find 12 real ones, give 12 and explain
+
+**When creating spreadsheets, documents, or reports with data:**
+- Every data point must be sourced from real research, the user's files, or connected apps
+- Clearly label any estimates or approximations as such
+- Do not generate sample/placeholder data unless the user explicitly asks for dummy or test data
+- If asked to "fill in" a template with real data, only fill fields you can verify
+
+**If you can't find the data:** Say so. "I could only find verified info for 8 of the 20 companies" is always better than silently making up the other 12.
+
+---
+
 # REMINDERS vs SCHEDULED TASKS - KNOW THE DIFFERENCE
 
 ## Use macOS Reminders App for SIMPLE TIME-BASED REMINDERS:
@@ -483,6 +523,16 @@ lemon-cron add "Hourly Reminder" "0 * * * *" "lemon-cron notify 'Another hour ha
 - Notify only → Reminders app
 - Do something → lemon-cron
 
+## Missed Tasks
+
+If the user says "run my missed tasks", "what tasks did I miss", "any missed cron jobs", or similar:
+1. Run `lemon-cron list` to see all jobs and their last status
+2. Look for jobs with `lastStatus: "missed"` or `lastStatus: "error"`
+3. For each missed/failed job, offer to re-run it with `lemon-cron run <jobId>`
+4. If there are no missed tasks, say "No missed tasks."
+
+Cron jobs can miss their schedule when the laptop is asleep or Lemonade isn't running. When the user wakes their laptop, they may get notifications about missed tasks with a "Run Now" button. If they ask you to run them instead, use the `cron` tool to force-run the missed jobs.
+
 ---
 
 # BROWSER RULES (READ BEFORE USING ANY BROWSER TOOL)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"

package/skills/image-generation/SKILL.md

@@ -1,15 +1,28 @@
 ---
 name: image-generation
-description: Generate images using DALL-E 3 or GPT Image models. Create artwork, illustrations, photos, designs. Triggers on: generate image, create picture, make art, draw, illustration, design image
+description: Generate images using DALL-E 3 or Nano Banana Pro (Gemini 3 Pro Image). Create artwork, illustrations, photos, designs, edit images. Triggers on: generate image, create picture, make art, draw, illustration, design image, edit image
 ---
 
 # Image Generation Skill
 
-Generate images using OpenAI's image generation API, routed through the backend proxy.
+Generate images using either **DALL-E 3** (OpenAI) or **Nano Banana Pro** (Gemini 3 Pro Image), routed through the Lemonade backend proxy.
 
-## CRITICAL: How to Generate Images
+## Model Selection
 
-Use the `exec` tool to run a Python script. The script routes through the Lemonade backend proxy — no local API key needed.
+Check the `IMAGE_GEN_MODEL` environment variable to decide which model to use:
+
+- `dall-e-3` → Use DALL-E 3 (OpenAI) — text-to-image only
+- `nano-banana-pro` → Use Nano Banana Pro (Gemini 3 Pro Image) — text-to-image, editing, multi-image composition
+
+If `IMAGE_GEN_MODEL` is not set, default to `dall-e-3`.
+
+**To check:** run `echo $IMAGE_GEN_MODEL` with the `exec` tool before generating.
+
+---
+
+## DALL-E 3 (OpenAI)
+
+Use the `exec` tool to run an inline Python script. Routes through the Lemonade backend proxy — no local API key needed.
 
 ```python
 import openai
@@ -43,6 +56,55 @@ urllib.request.urlretrieve(image_url, filepath)
 print(f"Image saved to Desktop: {filename}")
 ```
 
+### DALL-E 3 Size Options
+
+| Size | Aspect Ratio | Best For |
+|------|--------------|----------|
+| 1024x1024 | Square | Profile pictures, icons |
+| 1792x1024 | Landscape | Desktop wallpapers, banners |
+| 1024x1792 | Portrait | Phone wallpapers, posters |
+
+### DALL-E 3 Quality Options
+
+| Quality | Description |
+|---------|-------------|
+| standard | Good for most uses |
+| hd | More detailed, sharper |
+
+---
+
+## Nano Banana Pro (Gemini 3 Pro Image)
+
+Use the bundled script via `exec`. Routes through the Lemonade backend proxy when `LEMON_BACKEND_URL` and `GATEWAY_TOKEN` are set, otherwise falls back to `GEMINI_API_KEY`.
+
+### Generate
+
+```bash
+uv run {baseDir}/scripts/generate_image.py --prompt "your image description" --filename ~/Desktop/output.png --resolution 1K
+```
+
+### Edit (single image)
+
+```bash
+uv run {baseDir}/scripts/generate_image.py --prompt "edit instructions" --filename ~/Desktop/output.png -i "/path/to/input.png" --resolution 2K
+```
+
+### Multi-image composition (up to 14 images)
+
+```bash
+uv run {baseDir}/scripts/generate_image.py --prompt "combine these into one scene" --filename ~/Desktop/output.png -i img1.png -i img2.png -i img3.png
+```
+
+### Nano Banana Pro Resolutions
+
+| Resolution | Best For |
+|------------|----------|
+| 1K (default) | Quick previews, social media |
+| 2K | Prints, detailed work |
+| 4K | High-resolution output |
+
+---
+
 ## Prompt Best Practices
 
 ### Be Specific
@@ -58,31 +120,21 @@ print(f"Image saved to Desktop: {filename}")
 - Mood: "serene", "energetic", "mysterious"
 - Colors: "vibrant colors", "muted tones", "black and white"
 
-## Size Options
-
-| Size | Aspect Ratio | Best For |
-|------|--------------|----------|
-| 1024x1024 | Square | Profile pictures, icons |
-| 1792x1024 | Landscape | Desktop wallpapers, banners |
-| 1024x1792 | Portrait | Phone wallpapers, posters |
-
-## Quality Options
-
-| Quality | Description |
-|---------|-------------|
-| standard | Good for most uses |
-| hd | More detailed, sharper |
-
 ## Workflow
 
-1. **Understand request** - What does the user want to create?
-2. **Craft detailed prompt** - Add style, lighting, composition details
-3. **Generate image** - Run the Python script
-4. **Save to Desktop** - So user can easily find it
-5. **Confirm** - Tell user where the image was saved
+1. **Check model** — run `echo $IMAGE_GEN_MODEL` to determine which backend to use
+2. **Understand request** — What does the user want to create or edit?
+3. **Choose model** — If editing or compositing, prefer Nano Banana Pro (if activated). For text-to-image, use whichever is set.
+4. **Craft detailed prompt** — Add style, lighting, composition details
+5. **Generate image** — Run the appropriate script
+6. **Save to Desktop** — Use `~/Desktop/` with timestamped filename
+7. **Confirm** — Tell user where the image was saved
 
 ## Important Notes
 
 - Always save generated images to `~/Desktop/` for easy access
-- Images expire from the URL after ~1 hour, so always save locally
-- Always install openai package first if needed: `source ~/.lemonade/.venv/bin/activate && pip install -q openai`
+- DALL-E image URLs expire after ~1 hour, so always save locally
+- For DALL-E, install openai if needed: `source ~/.lemonade/.venv/bin/activate && pip install -q openai`
+- Nano Banana Pro requires `uv` — install via `brew install uv` if missing
+- Use timestamps in filenames: `yyyy-mm-dd-hh-mm-ss-name.png`
+- The Nano Banana Pro script prints a `MEDIA:` line for Lemonade to auto-attach on supported providers

package/skills/image-generation/scripts/generate_image.py

@@ -0,0 +1,201 @@
+#!/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 get_proxy_config() -> tuple[str | None, str | None]:
+    """Get backend proxy URL and gateway token for server-side API key routing."""
+    backend_url = os.environ.get("LEMON_BACKEND_URL", "").rstrip("/")
+    gateway_token = os.environ.get("GATEWAY_TOKEN", "")
+    if backend_url and gateway_token:
+        return f"{backend_url}/api/lemonade/proxy/gemini", gateway_token
+    return None, None
+
+
+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()
+
+    # Prefer backend proxy (API key stays server-side), fall back to local key
+    proxy_url, gateway_token = get_proxy_config()
+    api_key = get_api_key(args.api_key)
+
+    if not proxy_url and not api_key:
+        print("Error: No API key or backend proxy available.", file=sys.stderr)
+        print("Please either:", file=sys.stderr)
+        print("  1. Set LEMON_BACKEND_URL + GATEWAY_TOKEN (backend proxy)", file=sys.stderr)
+        print("  2. Provide --api-key argument", file=sys.stderr)
+        print("  3. Set GEMINI_API_KEY environment variable", file=sys.stderr)
+        sys.exit(1)
+
+    from google import genai
+    from google.genai import types
+    from PIL import Image as PILImage
+
+    if proxy_url:
+        print(f"Using backend proxy for Gemini API")
+        client = genai.Client(
+            api_key=gateway_token,
+            http_options=types.HttpOptions(api_endpoint=proxy_url),
+        )
+    else:
+        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}")
+            # Lemonade 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()