needware-cli 1.6.10 → 1.6.12

package/package.json

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

package/skills/add-skill-integration/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: add-skill-integration
+description: Create new skills to integrate third-party services or features into user projects. Use this skill when adding new service integrations.
+---
+
+# Add Skill Integration
+
+## Overview
+
+This skill guides you on how to install skills into user projects. Skills are modular integration guides that help integrate third-party services and features.
+
+## When to Use This Skill
+
+Use this skill when users:
+- Need to add new service integrations (databases, APIs, etc.)
+- Want to create custom skill documentation
+
+## Quick Start
+
+### Install Skills
+
+Use `add-skill` to install skills from a Git repository to your agent:
+
+```bash
+
+# Install to Claude Code
+npx add-skill https://github.com/your-org/your-skills -a claude-code -y
+
+# GitHub shorthand
+npx add-skill vercel-labs/agent-skills -a claude-code -y
+
+# Full GitHub URL
+npx add-skill https://github.com/vercel-labs/agent-skills -a claude-code -y
+
+# Direct path to a skill in a repo
+npx add-skill https://github.com/vercel-labs/agent-skills/tree/main/skills/ frontend-design -a claude-code -y
+
+# GitLab URL
+npx add-skill https://gitlab.com/org/repo -a claude-code -y
+
+# Any git URL
+npx add-skill git@github.com:vercel-labs/agent-skills.git -a claude-code -y
+### Supported Agents
+
+- More agents see [add-skill documentation](https://github.com/vercel-labs/add-skill)
+
+```
+
+## Example References
+
+Reference existing skill implementations:
+
+- [Vercel Agent Skills](https://github.com/vercel-labs/agent-skills)
+- [Remotion Skills](https://github.com/remotion-dev/skills)
+
+

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,31 +54,14 @@ 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
 
@@ -515,6 +500,182 @@ 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 } 
+        }
+      );
+    }
+
+    // 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("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: {
+        "Authorization": `Bearer ${AI_API_KEY}`,
+        "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.
@@ -660,7 +821,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)