lua-cli 1.1.4-beta.2 → 1.2.0

package/template/services/GetWeather.ts

@@ -1,8 +1,40 @@
-export default class GetWeatherMain{
+export interface WeatherData {
+    weather: string;
+    city: string;
+    temperature?: number;
+    humidity?: number;
+    description?: string;
+}
+
+export default class GetWeatherService {
+    // Mock weather data - in a real app, this would call a weather API
+    weatherData: Record<string, WeatherData>;
+
     constructor() {
+        this.weatherData = {
+            "london": { weather: "cloudy", city: "London", temperature: 15, humidity: 80, description: "Overcast with light rain" },
+            "paris": { weather: "sunny", city: "Paris", temperature: 22, humidity: 60, description: "Clear skies" },
+            "tokyo": { weather: "rainy", city: "Tokyo", temperature: 18, humidity: 85, description: "Heavy rainfall" },
+            "new york": { weather: "sunny", city: "New York", temperature: 25, humidity: 55, description: "Partly cloudy" },
+            "sydney": { weather: "sunny", city: "Sydney", temperature: 28, humidity: 45, description: "Clear and warm" }
+        };
     }
 
-    async getWeather(city: string) {
-        return { weather: "sunny", city: city };
+    async getWeather(city: string): Promise<WeatherData> {
+        const normalizedCity = city.toLowerCase().trim();
+        
+        // Return cached data if available, otherwise return generic response
+        const weatherInfo = this.weatherData[normalizedCity] || {
+            weather: "unknown",
+            city: city,
+            temperature: 20,
+            humidity: 50,
+            description: "Weather data not available"
+        };
+
+        // Simulate API delay
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        return weatherInfo;
     }
 }

package/template/services/MathService.ts

@@ -0,0 +1,61 @@
+// 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/tools/AdvancedMathTool.ts

@@ -0,0 +1,82 @@
+// 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) {
+    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/tools/CalculatorTool.ts

@@ -0,0 +1,65 @@
+// 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) {
+    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/tools/CreatePostTool.ts

@@ -2,14 +2,26 @@ import { LuaTool } from "lua-cli/skill";
 import { z } from "zod";
 import ApiService from "../services/ApiService";
 
-const inputSchema = z.object({ title: z.string(), content: z.string() });
-const outputSchema = z.object({ id: z.string(), title: z.string(), status: z.string(), error: z.string().optional(), url: z.string().nullable() });
+// Define schemas as static properties for Lua CLI detection
+const inputSchema = z.object({ 
+    title: z.string(), 
+    content: z.string() 
+});
 
-export default class CreatePostTool implements LuaTool<typeof inputSchema, typeof outputSchema>{
+const outputSchema = z.object({ 
+    id: z.string().nullable(), 
+    title: z.string(), 
+    status: z.string(), 
+    error: z.string().optional(), 
+    url: z.string().nullable() 
+});
+
+export default class CreatePostTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
     name: string;
     description: string;
     inputSchema: typeof inputSchema;
     outputSchema: typeof outputSchema;
+    
     apiService: ApiService;
     
     constructor() {

package/template/tools/GetUserDataTool.ts

@@ -2,14 +2,26 @@ import { LuaTool } from "lua-cli/skill";
 import { z } from "zod";
 import ApiService from "../services/ApiService";
 
-const inputSchema = z.object({ userId: z.string() });
-const outputSchema = z.object({ id: z.string(), name: z.string(), url: z.string(), status: z.string(), error: z.string().optional(), timestamp: z.string() });
+// Define schemas as static properties for Lua CLI detection
+const inputSchema = z.object({ 
+    userId: z.string() 
+});
 
-export default class GetUserDataTool implements LuaTool<typeof inputSchema, typeof outputSchema>{
+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() {

package/template/tools/GetWeatherTool.ts

@@ -1,24 +1,37 @@
 import { LuaTool } from "lua-cli/skill";
 import { z } from "zod";
-import GetWeatherMain from "../services/GetWeather";
+import GetWeatherService from "../services/GetWeather";
 
-const inputSchema = z.object({ city: z.string() });
-const outputSchema = z.object({ weather: z.string() });
+// Define schemas as static properties for Lua CLI detection
+const inputSchema = z.object({ 
+    city: z.string() 
+});
 
-export default class GetWeatherTool implements LuaTool<typeof inputSchema, typeof outputSchema>{
+const outputSchema = z.object({ 
+    weather: z.string(), 
+    city: z.string(),
+    temperature: z.number().optional(),
+    humidity: z.number().optional(),
+    description: z.string().optional()
+});
+
+export default class GetWeatherTool implements LuaTool<typeof inputSchema, typeof outputSchema> {
     name: string;
     description: string;
     inputSchema: typeof inputSchema;
     outputSchema: typeof outputSchema;
+    
+    weatherService: GetWeatherService;
 
     constructor() {
         this.name = "get_weather";
         this.description = "Get the weather for a given city";
         this.inputSchema = inputSchema;
         this.outputSchema = outputSchema;
+        this.weatherService = new GetWeatherService();
     }
 
     async execute(input: z.infer<typeof inputSchema>) {
-        return { weather: "sunny", city: input.city };
+        return this.weatherService.getWeather(input.city);
     }
 }