needware-cli 1.6.11 → 1.6.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "needware-cli",
-  "version": "1.6.11",
+  "version": "1.6.15",
   "description": "一个功能强大的 Node.js 命令行工具",
   "type": "module",
   "main": "dist/index.js",

package/skills/ai-integration/SKILL.md

@@ -9,24 +9,26 @@ description: Use this skill when the conversation requires integrating AI servic
 
 **CRITICAL**: AI Integration requires Supabase as the backend (uses Supabase Edge Functions). Always check Supabase integration status before proceeding:
 
-**Step 1: Check Existing Supabase Integration**
+
+**Step 1: Check Supabase Integration**
 
 Check if Supabase is already integrated:
 - Look for `src/lib/supabase.ts` file
 - Check `.env` file for Supabase environment variables:
   - `VITE_SUPABASE_PROJECT_ID`
-  - `VITE_SUPABASE_PUBLISHABLE_KEY` or `VITE_SUPABASE_ANON_KEY`
+  - `VITE_SUPABASE_PUBLISHABLE_KEY`
   - `VITE_SUPABASE_URL`
 
 **Step 2: Handle Based on Status**
 
 **If Supabase is already integrated** (supabase.ts exists with valid configuration):
-- ✓ Inform user: "Supabase is already integrated. Proceeding with AI integration..."
-- Continue with AI integration workflow below
+- ✓ Proceed with Resend integration
+- Inform user: "✓ Supabase is integrated. Proceeding with Resend setup."
 
-**If Supabase is NOT integrated** (no supabase.ts):
-- ⚠️ Stop immediately and inform user: "AI integration requires Supabase backend. Setting up Supabase first..."
-- use the `supabase-integration` skill
+**If Supabase is NOT integrated** (no supabase.ts or missing environment variables):
+- ❌ Stop immediately
+- Inform user: "⚠️ Supabase integration is required before setting up Resend. Resend email functions run on Supabase Edge Functions."
+- Suggest: "Please enable Supabase first by saying 'Enable Cloud' or use the supabase-integration skill."
 
 ---
 
@@ -52,38 +54,20 @@ Trigger Conditions (use if any are met):
 - Need to call large language model APIs (GPT, Claude, Gemini, etc.)
 - Need visual AI capabilities (OCR, object recognition, image analysis)
 - Need text AI capabilities (translation, summarization, sentiment analysis)
+- Need image generation capabilities (text-to-image, AI art generation) 🎨
 - User asks "how to integrate AI"
 ```
 
-## Supabase Project Structure
 
-After generating AI integration code, the project structure looks like this:
+## Model Selection Guide
 
-```
-project-root/
-├── supabase/
-│   ├── functions/
-│   │   ├── <function-name-1>/
-│   │   │   └── index.ts          # AI Feature 1
-│   │   ├── <function-name-2>/
-│   │   │   └── index.ts          # AI Feature 2
-│   │   └── <function-name-3>/
-│   │       └── index.ts          # AI Feature 3
-│   ├── .env.local                # Functions environment variables
-│   └── config.toml               # Supabase configuration
-├── src/
-│   ├── lib/
-│   │   └── supabase.ts           # Supabase Client configuration
-│   └── ...
-└── .env                          # Frontend environment variables (VITE_SUPABASE_URL, etc.)
-```
+**IMPORTANT:** Use `gemini-3-pro-image-preview` model for image generation, and `google/gemini-2.5-flash` model for text/image analysis.
 
 ## AI Integration Architecture Patterns
 
 ### 1. Backend API Pattern (Recommended for Production)
 
 **Use Cases:**
-- Need to protect API keys
 - Need rate limiting and usage control
 - Need data preprocessing or postprocessing
 - Need caching or logging
@@ -97,7 +81,6 @@ Frontend → Backend API → AI Gateway/Service → AI Provider
 
 **Use Cases:**
 - Prototyping or demos
-- Using user's own API keys
 - Scenarios requiring extremely high real-time performance
 
 **Architecture:**
@@ -161,19 +144,12 @@ const handler = async (req: Request): Promise<Response> => {
       );
     }
 
-    // Get API key from environment variables
-    const AI_API_KEY = Deno.env.get("AI_API_KEY");
-    if (!AI_API_KEY) {
-      throw new Error("AI service not configured");
-    }
-
     console.log("Processing AI request...");
 
     // Call AI Gateway API
     const response = await fetch("https://ai.gateway.needware.dev/v1/chat/completions", {
       method: "POST",
       headers: {
-        "Authorization": `Bearer ${AI_API_KEY}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -515,6 +491,175 @@ export function ChatInterface() {
 }
 ```
 
+### Image Generation Specialized Template
+
+**CRITICAL: Use `gemini-3-pro-image-preview` model for image generation tasks.**
+
+Use this template when users need to generate images from text descriptions.
+
+**File Location:** `supabase/functions/generate-image/index.ts`
+
+```typescript
+// supabase/functions/generate-image/index.ts
+import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
+
+// CORS headers for cross-origin requests
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Headers":
+    "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Max-Age": "86400",
+};
+
+// Request interface
+interface ImageGenerationRequest {
+  prompt: string;
+  options?: {
+    size?: string;
+    quality?: string;
+    style?: string;
+  };
+}
+
+const handler = async (req: Request): Promise<Response> => {
+  // Handle CORS preflight requests
+  if (req.method === "OPTIONS") {
+    return new Response(null, { 
+      status: 200,
+      headers: corsHeaders 
+    });
+  }
+
+  try {
+    const { prompt, options }: ImageGenerationRequest = await req.json();
+
+    // Validate input
+    if (!prompt) {
+      return new Response(
+        JSON.stringify({ error: "No prompt provided" }),
+        { 
+          status: 400, 
+          headers: { "Content-Type": "application/json", ...corsHeaders } 
+        }
+      );
+    }
+
+    console.log("Generating image with prompt:", prompt);
+
+    // Call AI Gateway API with image generation model
+    const response = await fetch("https://ai.gateway.needware.dev/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "gemini-3-pro-image-preview", // 🎨 Use image generation model
+        messages: [
+          {
+            role: "system",
+            content: "You are a professional image generation assistant. Generate high-quality images based on user descriptions."
+          },
+          {
+            role: "user",
+            content: prompt
+          }
+        ],
+        temperature: 0.8,
+        max_tokens: 4000,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("AI service error:", response.status, errorText);
+      throw new Error(`Image generation failed: ${errorText}`);
+    }
+
+    const data = await response.json();
+    const result = data.choices?.[0]?.message?.content;
+
+    if (!result) {
+      throw new Error("No image generated");
+    }
+
+    console.log("Image generation completed");
+
+    return new Response(
+      JSON.stringify({ 
+        success: true,
+        imageUrl: result, // Image URL or base64 data
+        prompt: prompt,
+        model: "gemini-3-pro-image-preview"
+      }),
+      { 
+        status: 200,
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
+    );
+
+  } catch (error: any) {
+    console.error("Image generation error:", error);
+    return new Response(
+      JSON.stringify({ error: error.message || "Unknown error" }),
+      { 
+        status: 500, 
+        headers: { "Content-Type": "application/json", ...corsHeaders } 
+      }
+    );
+  }
+};
+
+serve(handler);
+```
+
+**Frontend Usage Example:**
+
+```typescript
+import { useState } from 'react';
+import { supabase } from '@/lib/supabase';
+import { toast } from 'sonner';
+
+export function ImageGenerator() {
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [generatedImage, setGeneratedImage] = useState<string | null>(null);
+
+  const handleGenerate = async (prompt: string) => {
+    setIsGenerating(true);
+
+    try {
+      const { data, error } = await supabase.functions.invoke('generate-image', {
+        body: { 
+          prompt,
+          options: {
+            size: '1024x1024',
+            quality: 'high'
+          }
+        }
+      });
+
+      if (error) throw error;
+      if (data?.error) throw new Error(data.error);
+
+      setGeneratedImage(data.imageUrl);
+      toast.success("图片生成成功！");
+    } catch (error) {
+      console.error("Image generation error:", error);
+      toast.error(error instanceof Error ? error.message : "图片生成失败");
+    } finally {
+      setIsGenerating(false);
+    }
+  };
+
+  return (
+    <div>
+      {generatedImage && <img src={generatedImage} alt="Generated" />}
+      {/* UI components */}
+    </div>
+  );
+}
+```
+
 ### Image Analysis Specialized Template
 
 Use this template when users need image analysis functionality.
@@ -563,19 +708,12 @@ const handler = async (req: Request): Promise<Response> => {
       );
     }
 
-    // Get AI API key from environment
-    const AI_API_KEY = Deno.env.get("AI_API_KEY");
-    if (!AI_API_KEY) {
-      throw new Error("AI service not configured");
-    }
-
     console.log("Analyzing image...");
 
     // Call AI Gateway API
     const response = await fetch("https://ai.gateway.needware.dev/v1/chat/completions", {
       method: "POST",
       headers: {
-        "Authorization": `Bearer ${AI_API_KEY}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -660,7 +798,8 @@ serve(handler);
 When users request AI integration, follow these steps:
 
 ### Step 1: Requirements Analysis
-- [ ] Confirm AI functionality type (image/text/speech/other)
+- [ ] Confirm AI functionality type (image analysis/image generation/text/speech/other)
+- [ ] If image generation: Use `gemini-3-pro-image-preview` model 🎨
 - [ ] Confirm input/output formats
 - [ ] Confirm if structured response is needed
 - [ ] Confirm performance requirements (response time, concurrency)
@@ -696,76 +835,10 @@ pnpm add @supabase/supabase-js
 - Function names should clearly express functionality
 - Each feature gets its own independent function directory
 
-### Step 6: Configure Environment Variables
-
-**Configure in Supabase Dashboard:**
-1. Go to Project Settings → Edge Functions → Secrets
-2. Add environment variables:
-   - `AI_API_KEY`: Your AI service API key
-   - `AI_MODEL`: (Optional) Default model name
-   - `AI_MAX_TOKENS`: (Optional) Maximum token count
-
-**Or use Supabase CLI:**
-```bash
-# Set secrets
-supabase secrets set AI_API_KEY=your_api_key_here
-supabase secrets set AI_MODEL=google/gemini-2.5-flash
-supabase secrets set AI_MAX_TOKENS=2000
-```
-
-**Local Development Environment Variables:**
-Create `supabase/.env.local` file (for Supabase Functions):
-```bash
-AI_API_KEY=your_api_key_here
-AI_MODEL=google/gemini-2.5-flash
-AI_MAX_TOKENS=2000
-```
-
-**Frontend Environment Variables:**
-Configure in `.env` or `.env.local` file:
-```bash
-VITE_SUPABASE_URL=your_supabase_project_url
-VITE_SUPABASE_ANON_KEY=your_supabase_anon_key
-```
-
-### Step 7: Testing
-
-**Test Supabase Function Locally:**
-```bash
-# Start local Supabase
-supabase start
-
-# Deploy function locally
-supabase functions serve <function-name>
-
-# Test invocation (text example)
-curl -i --location --request POST 'http://localhost:54321/functions/v1/<function-name>' \
-  --header 'Authorization: Bearer YOUR_ANON_KEY' \
-  --header 'Content-Type: application/json' \
-  --data '{"text":"test text","options":{"model":"google/gemini-2.5-flash"}}'
-
-# Test invocation (image example)
-curl -i --location --request POST 'http://localhost:54321/functions/v1/<function-name>' \
-  --header 'Authorization: Bearer YOUR_ANON_KEY' \
-  --header 'Content-Type: application/json' \
-  --data '{"image":"data:image/png;base64,...","prompt":"Please analyze this image"}'
-```
-
-**Deploy to Production:**
-```bash
-# Deploy function
-supabase functions deploy <function-name>
-
-# View logs
-supabase functions logs <function-name>
-```
-
 
 ## Best Practices
 
 ### Security
-- ✅ **Never** expose API keys in the frontend
-- ✅ Use environment variables to store sensitive information
 - ✅ Implement request rate limiting
 - ✅ Validate and sanitize user input
 - ✅ Add request size limits
@@ -784,7 +857,7 @@ supabase functions logs <function-name>
 const handleAIError = (error: any, statusCode: number) => {
   const errorMap: Record<number, string> = {
     400: "Invalid request parameters",
-    401: "API key invalid or expired",
+    401: "Authentication failed",
     402: "Insufficient account balance or quota exhausted",
     403: "No permission to access this API",
     404: "API endpoint does not exist",
@@ -814,11 +887,10 @@ const handleAIError = (error: any, statusCode: number) => {
 
 **After completing AI integration, must:**
 1. ✅ Test all error scenarios
-2. ✅ Verify API key configuration
-3. ✅ Check response format correctness
-4. ✅ Test edge cases (extra-long input, special characters, etc.)
-5. ✅ Confirm smooth user experience
-6. ✅ Add usage documentation and examples
+2. ✅ Check response format correctness
+3. ✅ Test edge cases (extra-long input, special characters, etc.)
+4. ✅ Confirm smooth user experience
+5. ✅ Add usage documentation and examples
 
 **Remember: AI integration is not "set it and forget it", requires continuous monitoring and optimization.**