lua-cli 1.3.2-alpha.0 → 1.3.2-alpha.3

package/template/src/tools/GetWeatherTool.ts

@@ -1,37 +1,53 @@
 import { LuaTool } from "lua-cli/skill";
 import { z } from "zod";
-import GetWeatherService from "../services/GetWeather";
 
-// Define schemas as static properties for Lua CLI detection
-const inputSchema = z.object({ 
-    city: z.string() 
-});
+export default class GetWeatherTool implements LuaTool {
+    name = "get_weather";
+    description = "Get the weather for a given city";
+    inputSchema = z.object({
+        city: z.string()
+    });
+    outputSchema = z.object({
+        weather: z.string(),
+        city: z.string(),
+        temperature: z.number().optional(),
+        humidity: z.number().optional(),
+        description: z.string().optional()
+    });
 
-const outputSchema = z.object({ 
-    weather: z.string(), 
-    city: z.string(),
-    temperature: z.number().optional(),
-    humidity: z.number().optional(),
-    description: z.string().optional()
-});
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        // Step 1: Geocode city → lat/lon (use Open-Meteo’s free geocoding API)
+        const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(
+            input.city
+        )}&count=1`;
+        
+        const geoRes = await fetch(geoUrl);
+        if (!geoRes.ok) {
+            throw new Error(`Failed to fetch location: ${geoRes.statusText}`);
+        }
+        const geoData = await geoRes.json();
+        if (!geoData.results || geoData.results.length === 0) {
+            throw new Error(`No location found for ${input.city}`);
+        }
 
-export default class GetWeatherTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
-    name: string;
-    description: string;
-    inputSchema: typeof inputSchema;
-    outputSchema: typeof outputSchema;
-    
-    weatherService: GetWeatherService;
+        const { latitude, longitude, name } = geoData.results[0];
 
-    constructor() {
-        this.name = "get_weather";
-        this.description = "Get the weather for a given city";
-        this.inputSchema = inputSchema;
-        this.outputSchema = outputSchema;
-        this.weatherService = new GetWeatherService();
-    }
+        // Step 2: Get weather for lat/lon
+        const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current_weather=true`;
+        
+        const weatherRes = await fetch(weatherUrl);
+        if (!weatherRes.ok) {
+            throw new Error(`Failed to fetch weather: ${weatherRes.statusText}`);
+        }
+        const weatherData = await weatherRes.json();
+        const current = weatherData.current_weather;
 
-    async execute(input: z.infer<typeof inputSchema>) {
-        return this.weatherService.getWeather(input.city);
+        return {
+            weather: current.weathercode?.toString() || "Unknown",
+            city: name,
+            temperature: current.temperature,
+            humidity: undefined, // Open-Meteo current_weather does not include humidity
+            description: `Windspeed ${current.windspeed} km/h`
+        };
     }
-}
+}

package/template/src/tools/PaymentTool.ts

@@ -0,0 +1,52 @@
+import { LuaTool, env } from "lua-cli/skill";
+import { z } from "zod";
+
+export default class CreatePaymentLinkTool implements LuaTool {
+    name = "create_payment_link";
+    description = "Create a Stripe payment link for a one-time payment";
+    inputSchema = z.object({
+        amount: z.number().int().positive(), // in cents
+        currency: z.string().default("usd"),
+        quantity: z.number().int().positive().default(1),
+    });
+    outputSchema = z.object({
+        url: z.string(),
+        id: z.string(),
+    });
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        const apiKey = env("STRIPE_SECRET_KEY");
+        if (!apiKey) {
+            throw new Error("STRIPE_SECRET_KEY is not set in environment variables");
+        }
+
+        // Create a one-time Checkout Session with dummy redirect URLs
+        const sessionRes = await fetch("https://api.stripe.com/v1/checkout/sessions", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: new URLSearchParams({
+                mode: "payment",
+                "line_items[0][price_data][currency]": input.currency,
+                "line_items[0][price_data][product_data][name]": "One-time Payment",
+                "line_items[0][price_data][unit_amount]": input.amount.toString(),
+                "line_items[0][quantity]": input.quantity.toString(),
+                success_url: "https://example.com/success",
+                cancel_url: "https://example.com/cancel",
+            }),
+        });
+
+        if (!sessionRes.ok) {
+            throw new Error(`Failed to create checkout session: ${await sessionRes.text()}`);
+        }
+
+        const session = await sessionRes.json();
+
+        return {
+            url: session.url,
+            id: session.id,
+        };
+    }
+}

package/template/src/tools/SearchProducts.ts

@@ -0,0 +1,43 @@
+import { env, LuaTool } from "lua-cli/skill";
+import { z } from "zod";
+import { user } from 'lua-cli/user-data-api';
+import { Pinecone, Index } from '@pinecone-database/pinecone';
+import OpenAI from "openai";
+export class SearchProductsTool implements LuaTool {
+    name = "search_products";
+    description = "Search for products";
+    inputSchema = z.object({
+        query: z.string()
+    });
+    pinecone: Pinecone;
+    openai: OpenAI;
+    index: Index;
+
+    constructor() {
+        const pinecone = new Pinecone({
+            apiKey: env('PINECONE_API_KEY') || ''
+        });
+        this.openai = new OpenAI({ apiKey: env('OPENAI_API_KEY') || '' });
+        this.pinecone = pinecone;
+        this.index = pinecone.Index('products-demo');
+    }
+
+    async embedText(text: string) {
+        const embeddingResponse = await this.openai.embeddings.create({
+            model: "text-embedding-3-small",
+            input: text,
+        });
+        return embeddingResponse.data[0].embedding;
+    }
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        const queryVector = await this.embedText(input.query);
+        const results = await this.index.query({
+            vector: queryVector,
+            topK: 3,
+            includeMetadata: true,
+          });
+        console.log(results);
+        return results;
+    }
+}

package/template/src/tools/UserDataTool.ts

@@ -0,0 +1,56 @@
+import { LuaTool } from "lua-cli/skill";
+import { z } from "zod";
+import { user } from 'lua-cli/user-data-api';
+
+
+export class GetUserDataTool implements LuaTool {
+    name = "get_user_data";
+    description = "Get the user data for a given user id";
+    inputSchema = z.object({ });
+
+    constructor() {}
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        return user.data.get();
+    }
+}
+
+
+export class CreateUserDataTool implements LuaTool {
+    name = "create_user_data";
+    description = "Get the user data for a given user id";
+    inputSchema = z.object({ 
+        data: z.object({
+            name: z.string(),
+            age: z.number()
+        })
+    });
+
+    constructor() {}
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        console.log('createUserData tool', input);
+        const userData = await user.data.get();
+        if (userData.data) {
+            return user.data.update(input.data);
+        }
+        return user.data.create(input.data);
+    }
+}
+
+export class UpdateUserDataTool implements LuaTool {
+    name = "update_user_data";
+    description = "Update the user data for a given user id";
+    inputSchema = z.object({ 
+        data: z.object({
+            name: z.string().optional(),
+            age: z.number().optional()
+        })
+    });
+
+    constructor() {}
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        return user.data.update(input.data);
+    }
+}

package/template/src/services/MathService.ts

@@ -1,61 +0,0 @@
-// Example: Simple Math Service
-export default class MathService {
-  /**
-   * Calculate the factorial of a number
-   */
-  factorial(n: number): number {
-    if (n < 0) throw new Error("Factorial is not defined for negative numbers");
-    if (n === 0 || n === 1) return 1;
-    return n * this.factorial(n - 1);
-  }
-  
-  /**
-   * Check if a number is prime
-   */
-  isPrime(n: number): boolean {
-    if (n < 2) return false;
-    if (n === 2) return true;
-    if (n % 2 === 0) return false;
-    
-    for (let i = 3; i <= Math.sqrt(n); i += 2) {
-      if (n % i === 0) return false;
-    }
-    
-    return true;
-  }
-  
-  /**
-   * Generate Fibonacci sequence up to n terms
-   */
-  fibonacci(n: number): number[] {
-    if (n <= 0) return [];
-    if (n === 1) return [0];
-    if (n === 2) return [0, 1];
-    
-    const sequence = [0, 1];
-    for (let i = 2; i < n; i++) {
-      sequence.push(sequence[i - 1] + sequence[i - 2]);
-    }
-    
-    return sequence;
-  }
-  
-  /**
-   * Calculate the greatest common divisor
-   */
-  gcd(a: number, b: number): number {
-    while (b !== 0) {
-      const temp = b;
-      b = a % b;
-      a = temp;
-    }
-    return Math.abs(a);
-  }
-  
-  /**
-   * Calculate the least common multiple
-   */
-  lcm(a: number, b: number): number {
-    return Math.abs(a * b) / this.gcd(a, b);
-  }
-}

package/template/src/tools/AdvancedMathTool.ts

@@ -1,82 +0,0 @@
-// Example: Advanced Math Tool using MathService
-import { LuaTool } from "lua-cli/skill";
-import { z } from "zod";
-import MathService from "../services/MathService";
-
-// Define schemas as static properties for Lua CLI detection
-const inputSchema = z.object({
-  operation: z.enum(["factorial", "is_prime", "fibonacci", "gcd", "lcm"]).describe("Mathematical operation"),
-  numbers: z.array(z.number()).describe("Numbers for the operation")
-});
-
-const outputSchema = z.object({
-  result: z.any(),
-  operation: z.string(),
-  input: z.array(z.number())
-});
-
-export default class AdvancedMathTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
-  name: string;
-  description: string;
-  inputSchema: typeof inputSchema;
-  outputSchema: typeof outputSchema;
-  private mathService: MathService;
-  
-  constructor() {
-    this.name = "advanced_math";
-    this.description = "Perform advanced mathematical operations";
-    this.inputSchema = inputSchema;
-    this.outputSchema = outputSchema;
-    this.mathService = new MathService();
-  }
-  
-  async execute(input: z.infer<typeof inputSchema>) {
-    let result: any;
-    
-    switch (input.operation) {
-      case "factorial":
-        if (input.numbers.length !== 1) {
-          throw new Error("Factorial requires exactly one number");
-        }
-        result = this.mathService.factorial(input.numbers[0]);
-        break;
-        
-      case "is_prime":
-        if (input.numbers.length !== 1) {
-          throw new Error("Prime check requires exactly one number");
-        }
-        result = this.mathService.isPrime(input.numbers[0]);
-        break;
-        
-      case "fibonacci":
-        if (input.numbers.length !== 1) {
-          throw new Error("Fibonacci requires exactly one number");
-        }
-        result = this.mathService.fibonacci(input.numbers[0]);
-        break;
-        
-      case "gcd":
-        if (input.numbers.length !== 2) {
-          throw new Error("GCD requires exactly two numbers");
-        }
-        result = this.mathService.gcd(input.numbers[0], input.numbers[1]);
-        break;
-        
-      case "lcm":
-        if (input.numbers.length !== 2) {
-          throw new Error("LCM requires exactly two numbers");
-        }
-        result = this.mathService.lcm(input.numbers[0], input.numbers[1]);
-        break;
-        
-      default:
-        throw new Error(`Unknown operation: ${input.operation}`);
-    }
-    
-    return {
-      result,
-      operation: input.operation,
-      input: input.numbers
-    };
-  }
-}

package/template/src/tools/CalculatorTool.ts

@@ -1,65 +0,0 @@
-// Example: Simple Calculator Tool
-import { LuaTool } from "lua-cli/skill";
-import { z } from "zod";
-
-// Define schemas as static properties for Lua CLI detection
-const inputSchema = z.object({
-  operation: z.enum(["add", "subtract", "multiply", "divide"]).describe("Mathematical operation"),
-  a: z.number().describe("First number"),
-  b: z.number().describe("Second number")
-});
-
-const outputSchema = z.object({
-  result: z.number(),
-  operation: z.string(),
-  expression: z.string()
-});
-
-export default class CalculatorTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
-  name: string;
-  description: string;
-  inputSchema: typeof inputSchema;
-  outputSchema: typeof outputSchema;
-  
-  constructor() {
-    this.name = "calculator";
-    this.description = "Perform basic mathematical operations";
-    this.inputSchema = inputSchema;
-    this.outputSchema = outputSchema;
-  }
-  
-  async execute(input: z.infer<typeof inputSchema>) {
-    let result: number;
-    let expression: string;
-    
-    switch (input.operation) {
-      case "add":
-        result = input.a + input.b;
-        expression = `${input.a} + ${input.b}`;
-        break;
-      case "subtract":
-        result = input.a - input.b;
-        expression = `${input.a} - ${input.b}`;
-        break;
-      case "multiply":
-        result = input.a * input.b;
-        expression = `${input.a} × ${input.b}`;
-        break;
-      case "divide":
-        if (input.b === 0) {
-          throw new Error("Division by zero is not allowed");
-        }
-        result = input.a / input.b;
-        expression = `${input.a} ÷ ${input.b}`;
-        break;
-      default:
-        throw new Error(`Unknown operation: ${input.operation}`);
-    }
-    
-    return {
-      result,
-      operation: input.operation,
-      expression
-    };
-  }
-}

package/template/src/tools/GetUserDataTool.ts

@@ -1,38 +0,0 @@
-import { LuaTool } from "lua-cli/skill";
-import { z } from "zod";
-import ApiService from "../services/ApiService";
-
-// Define schemas as static properties for Lua CLI detection
-const inputSchema = z.object({ 
-    userId: z.string() 
-});
-
-const outputSchema = z.object({ 
-    id: z.string(), 
-    name: z.string(), 
-    url: z.string().nullable(), 
-    status: z.string(), 
-    error: z.string().optional(), 
-    timestamp: z.string() 
-});
-
-export default class GetUserDataTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
-    name: string;
-    description: string;
-    inputSchema: typeof inputSchema;
-    outputSchema: typeof outputSchema;
-    
-    apiService: ApiService;
-
-    constructor() {
-        this.name = "get_user_data";
-        this.description = "Get the user data for a given user id";
-        this.inputSchema = inputSchema;
-        this.outputSchema = outputSchema;
-        this.apiService = new ApiService();
-    }
-
-    async execute(input: z.infer<typeof inputSchema>) {
-        return this.apiService.fetchUserData(input.userId);
-    }
-}

package/template/tools/UserPreferencesTool.ts

@@ -1,73 +0,0 @@
-import { LuaTool } from 'lua-cli/skill';
-import { user } from 'lua-cli/user-data-api';
-import { z } from 'zod';
-
-/**
- * Example tool demonstrating User Data API usage
- * This tool allows users to manage their preferences
- */
-export class UserPreferencesTool extends LuaTool {
-  constructor() {
-    super('user-preferences', 'Manage user preferences and settings');
-  }
-
-  async execute(input: { action: string; key?: string; value?: string }) {
-    const { action, key, value } = input;
-
-    try {
-      switch (action) {
-        case 'get':
-          const userData = await user.data.get();
-          return { 
-            success: true, 
-            preferences: userData.preferences || {},
-            message: 'Preferences retrieved successfully'
-          };
-        
-        case 'set':
-          if (!key || !value) {
-            throw new Error('Key and value are required for set action');
-          }
-          
-          const currentData = await user.data.get();
-          const updatedData = {
-            ...currentData,
-            preferences: {
-              ...currentData.preferences,
-              [key]: value
-            }
-          };
-          
-          await user.data.update(updatedData);
-          return { 
-            success: true, 
-            message: `Set ${key} to ${value}`,
-            preferences: updatedData.preferences
-          };
-        
-        case 'clear':
-          await user.data.clear();
-          return { 
-            success: true, 
-            message: 'All preferences cleared' 
-          };
-        
-        default:
-          throw new Error('Invalid action. Use: get, set, or clear');
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  getInputSchema() {
-    return z.object({
-      action: z.enum(['get', 'set', 'clear']).describe('Action to perform: get (retrieve preferences), set (update a preference), or clear (remove all preferences)'),
-      key: z.string().optional().describe('Preference key (required for set action)'),
-      value: z.string().optional().describe('Preference value (required for set action)')
-    });
-  }
-}