lua-cli 3.13.0 → 3.14.1

package/template/examples/skills/tools/GameScoreTrackerTool.ts

@@ -1,29 +1,29 @@
 /**
  * Game Score Tracker Tool - Complex Dynamic Job Example
- * 
+ *
  * This tool demonstrates:
  * 1. Creating a game tracking record
  * 2. Creating an interval job that starts at game time
  * 3. Job fetches score updates periodically
  * 4. Job checks if game is over
  * 5. Job deactivates itself when game ends
- * 
+ *
  * Use case: Live sports score tracking, esports matches, auction monitoring
  */
 
-import { LuaTool, Jobs, Data } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Jobs, Data } from 'lua-cli';
+import { z } from 'zod';
 
 export class TrackGameScoresTool implements LuaTool {
-  name = "track_game_scores";
-  description = "Track live scores for a game with automatic updates";
-  
+  name = 'track_game_scores';
+  description = 'Track live scores for a game with automatic updates';
+
   inputSchema = z.object({
     gameId: z.string(),
     gameName: z.string(),
     startTime: z.string(), // ISO 8601 timestamp
     updateIntervalSeconds: z.number().min(30).max(600).default(60), // 30s to 10min
-    apiEndpoint: z.string().optional() // Optional external API
+    apiEndpoint: z.string().optional(), // Optional external API
   });
 
   async execute(input: {
@@ -43,12 +43,10 @@ export class TrackGameScoresTool implements LuaTool {
       status: 'scheduled',
       currentScore: { home: 0, away: 0 },
       lastUpdate: new Date().toISOString(),
-      createdAt: new Date().toISOString()
+      createdAt: new Date().toISOString(),
     };
 
-    const game = await Data.create('games', gameRecord, 
-      `${input.gameName} ${input.gameId}`
-    );
+    const game = await Data.create('games', gameRecord, `${input.gameName} ${input.gameId}`);
 
     console.log(`✅ Game record created: ${game.id}`);
 
@@ -75,57 +73,57 @@ export class TrackGameScoresTool implements LuaTool {
     const job = await Jobs.create({
       name: `track-game-${gameId}`,
       description: `Live score tracking for ${gameName}`,
-      
+
       // Important: Use interval schedule
       schedule: {
         type: 'interval',
-        seconds: intervalSeconds
+        seconds: intervalSeconds,
       },
-      
-      timeout: 30,  // Each update should complete in 30 seconds
-      
+
+      timeout: 30, // Each update should complete in 30 seconds
+
       retry: {
-        maxAttempts: 2,  // Retry failed updates
-        backoffSeconds: 10
+        maxAttempts: 2, // Retry failed updates
+        backoffSeconds: 10,
       },
-      
+
       // The job logic - runs every interval until game ends
       execute: async () => {
         console.log('🎮 Fetching score update for game ' + gameId + '...');
-        
+
         try {
           // Fetch current game data from our database
           const gameData = await Data.getEntry('games', gameRecordId);
-          
+
           // Check if game is already over
           if (gameData.data.status === 'finished') {
             console.log('🏁 Game ' + gameId + ' is already finished. Stopping job.');
-            
+
             // IMPORTANT: Job stops itself using the instance method!
             await job.deactivate();
-            
+
             return {
               action: 'job-stopped',
               reason: 'game-finished',
               gameId: gameId,
-              finalScore: gameData.data.currentScore
+              finalScore: gameData.data.currentScore,
             };
           }
-          
+
           // Fetch latest scores from external API
           let scoreUpdate;
           try {
             const response = await fetch(apiEndpoint + '/' + gameId);
-            
+
             if (!response.ok) {
               throw new Error('API returned ' + response.status);
             }
-            
+
             scoreUpdate = await response.json();
           } catch (apiError) {
             // If external API fails, generate mock data for demo
             console.warn('External API failed, using mock data:', apiError);
-            
+
             // Simulate score progression
             const currentScore = gameData.data.currentScore;
             scoreUpdate = {
@@ -133,79 +131,78 @@ export class TrackGameScoresTool implements LuaTool {
               away: currentScore.away + Math.floor(Math.random() * 2),
               quarter: Math.min(4, Math.floor(Date.now() / 1000 / 60 / 15) % 5),
               timeRemaining: '12:34',
-              isFinished: Math.random() > 0.9  // 10% chance game ends
+              isFinished: Math.random() > 0.9, // 10% chance game ends
             };
           }
-          
+
           // Update game record with new scores
           const updatedGame = await Data.update('games', gameRecordId, {
             ...gameData.data,
             currentScore: {
               home: scoreUpdate.home,
-              away: scoreUpdate.away
+              away: scoreUpdate.away,
             },
             quarter: scoreUpdate.quarter,
             timeRemaining: scoreUpdate.timeRemaining,
             status: scoreUpdate.isFinished ? 'finished' : 'in-progress',
-            lastUpdate: new Date().toISOString()
+            lastUpdate: new Date().toISOString(),
           });
-          
+
           console.log('📊 Score update: ' + scoreUpdate.home + ' - ' + scoreUpdate.away);
-          
+
           // Check if game just ended
           if (scoreUpdate.isFinished) {
             console.log('🏁 Game ' + gameId + ' has finished!');
             console.log('Final score: ' + scoreUpdate.home + ' - ' + scoreUpdate.away);
-            
+
             // Store final game result
             await Data.create('game-results', {
               gameId: gameId,
               gameName: gameName,
               finalScore: {
                 home: scoreUpdate.home,
-                away: scoreUpdate.away
+                away: scoreUpdate.away,
               },
-              finishedAt: new Date().toISOString()
+              finishedAt: new Date().toISOString(),
             });
-            
+
             // IMPORTANT: Job stops itself when game ends using instance method!
             await job.deactivate();
-            
+
             console.log('⏹️  Score tracking job stopped for game ' + gameId);
-            
+
             return {
               action: 'game-ended-job-stopped',
               gameId: gameId,
               finalScore: {
                 home: scoreUpdate.home,
-                away: scoreUpdate.away
-              }
+                away: scoreUpdate.away,
+              },
             };
           }
-          
+
           // Game still in progress
           return {
             action: 'score-updated',
             gameId: gameId,
             currentScore: {
               home: scoreUpdate.home,
-              away: scoreUpdate.away
+              away: scoreUpdate.away,
             },
             quarter: scoreUpdate.quarter,
-            timeRemaining: scoreUpdate.timeRemaining
+            timeRemaining: scoreUpdate.timeRemaining,
           };
-          
         } catch (error: any) {
           console.error('❌ Error updating score for game ' + gameId + ':', error);
-          
+
           // Don't stop job on errors - just log and continue
           return {
             action: 'error',
             gameId: gameId,
-            error: error.message
+            error: error.message,
           };
         }
-      }
+      },
     });
 
     console.log(`✅ Score tracking job created: ${job.id}`);
@@ -219,30 +216,30 @@ export class TrackGameScoresTool implements LuaTool {
         gameId: input.gameId,
         name: input.gameName,
         startTime: input.startTime,
-        status: 'scheduled'
+        status: 'scheduled',
       },
       scoreTracker: {
         jobId: job.id,
         jobName: job.name,
         updateInterval: input.updateIntervalSeconds,
         startsAt: jobStartTime.toISOString(),
-        message: 'Job will automatically stop when game ends'
-      }
+        message: 'Job will automatically stop when game ends',
+      },
     };
   }
 }
 
 /**
  * Get Game Scores Tool
- * 
+ *
  * Retrieves current scores for a game or all active games
  */
 export class GetGameScoresTool implements LuaTool {
-  name = "get_game_scores";
-  description = "Get current scores for tracked games";
-  
+  name = 'get_game_scores';
+  description = 'Get current scores for tracked games';
+
   inputSchema = z.object({
-    gameId: z.string().optional()
+    gameId: z.string().optional(),
   });
 
   async execute(input: { gameId?: string }) {
@@ -250,12 +247,12 @@ export class GetGameScoresTool implements LuaTool {
       // Get specific game
       const games = await Data.get('games', {}, 1, 100);
       const game = games.data?.find((g: any) => g.data.gameId === input.gameId);
-      
+
       if (!game) {
         return {
           found: false,
           gameId: input.gameId,
-          message: 'Game not found'
+          message: 'Game not found',
         };
       }
 
@@ -268,14 +265,14 @@ export class GetGameScoresTool implements LuaTool {
           currentScore: game.data.currentScore,
           quarter: game.data.quarter,
           timeRemaining: game.data.timeRemaining,
-          lastUpdate: game.data.lastUpdate
-        }
+          lastUpdate: game.data.lastUpdate,
+        },
       };
     }
 
     // Get all active games
     const allGames = await Data.get('games', {}, 1, 50);
-    
+
     const activeGames = (allGames.data || [])
       .filter((g: any) => g.data.status === 'in-progress' || g.data.status === 'scheduled')
       .map((g: any) => ({
@@ -283,27 +280,27 @@ export class GetGameScoresTool implements LuaTool {
         name: g.data.gameName,
         status: g.data.status,
         currentScore: g.data.currentScore,
-        lastUpdate: g.data.lastUpdate
+        lastUpdate: g.data.lastUpdate,
       }));
 
     return {
       activeGamesCount: activeGames.length,
-      games: activeGames
+      games: activeGames,
     };
   }
 }
 
 /**
  * Stop Game Tracking Tool
- * 
+ *
  * Manually stops score tracking for a game
  */
 export class StopGameTrackingTool implements LuaTool {
-  name = "stop_game_tracking";
-  description = "Manually stop score tracking for a game";
-  
+  name = 'stop_game_tracking';
+  description = 'Manually stop score tracking for a game';
+
   inputSchema = z.object({
-    gameId: z.string()
+    gameId: z.string(),
   });
 
   async execute(input: { gameId: string }) {
@@ -312,15 +309,13 @@ export class StopGameTrackingTool implements LuaTool {
     // Find the tracking job - Jobs.getAll() returns array of JobInstance
     const allJobs = await Jobs.getAll({ includeDynamic: true });
 
-    const trackingJob = allJobs.find((j: any) => 
-      j.name === `track-game-${input.gameId}`
-    );
+    const trackingJob = allJobs.find((j: any) => j.name === `track-game-${input.gameId}`);
 
     if (!trackingJob) {
       return {
         success: false,
         gameId: input.gameId,
-        message: 'No tracking job found for this game'
+        message: 'No tracking job found for this game',
       };
     }
 
@@ -330,12 +325,12 @@ export class StopGameTrackingTool implements LuaTool {
     // Update game status
     const games = await Data.get('games', {}, 1, 100);
     const game = games.data?.find((g: any) => g.data.gameId === input.gameId);
-    
+
     if (game) {
       await Data.update('games', game.id, {
         ...game.data,
         status: 'stopped',
-        stoppedAt: new Date().toISOString()
+        stoppedAt: new Date().toISOString(),
       });
     }
 
@@ -345,8 +340,7 @@ export class StopGameTrackingTool implements LuaTool {
       success: true,
       gameId: input.gameId,
       jobId: trackingJob.id,
-      message: 'Score tracking stopped successfully'
+      message: 'Score tracking stopped successfully',
     };
   }
 }
-

package/template/examples/skills/tools/GetWeatherTool.ts

@@ -1,53 +1,51 @@
-import { LuaTool } from "lua-cli";
-import { z } from "zod";
+import { LuaTool } from 'lua-cli';
+import { z } from 'zod';
 
 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()
-    });
+  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(),
+  });
 
-    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}`);
-        }
+  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 { latitude, longitude, name } = geoData.results[0];
+    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}`);
+    }
 
-        // 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;
+    const { latitude, longitude, name } = geoData.results[0];
 
-        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`
-        };
+    // 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;
+
+    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/examples/skills/tools/OrderTool.ts

@@ -1,56 +1,56 @@
-import { LuaTool, Orders, } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Orders } from 'lua-cli';
+import { z } from 'zod';
 import { OrderStatus } from 'lua-cli';
 
-
-
 export class CreateOrderTool implements LuaTool {
-    name = "create_order";
-    description = "Create a new order";
-    inputSchema = z.object({
-        order: z.object({
-            basketId: z.string(),
-            data: z.object({
-                storeId: z.string(),
-            }).optional()
+  name = 'create_order';
+  description = 'Create a new order';
+  inputSchema = z.object({
+    order: z.object({
+      basketId: z.string(),
+      data: z
+        .object({
+          storeId: z.string(),
         })
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.create(input.order);
-    }
+        .optional(),
+    }),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.create(input.order);
+  }
 }
 
 export class UpdateOrderStatusTool implements LuaTool {
-    name = "update_order_status";
-    description = "Update the status of an order";
-    inputSchema = z.object({
-        orderId: z.string(),
-        status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled'])
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const order = await Orders.getById(input.orderId);
-        return order.updateStatus(input.status as OrderStatus);
-    }
+  name = 'update_order_status';
+  description = 'Update the status of an order';
+  inputSchema = z.object({
+    orderId: z.string(),
+    status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled']),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const order = await Orders.getById(input.orderId);
+    return order.updateStatus(input.status as OrderStatus);
+  }
 }
 
 export class GetUserOrdersTool implements LuaTool {
-    name = "get_user_orders";
-    description = "Get all orders for a user";
-    inputSchema = z.object({});
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.get();
-    }
+  name = 'get_user_orders';
+  description = 'Get all orders for a user';
+  inputSchema = z.object({});
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.get();
+  }
 }
 
 export class GetOrderByIdTool implements LuaTool {
-    name = "get_order_by_id";
-    description = "Get an order by id";
-    inputSchema = z.object({
-        orderId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.getById(input.orderId);
-    }
+  name = 'get_order_by_id';
+  description = 'Get an order by id';
+  inputSchema = z.object({
+    orderId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.getById(input.orderId);
+  }
 }
 
 /**
@@ -58,22 +58,22 @@ export class GetOrderByIdTool implements LuaTool {
  * Useful for adding tracking info, notes, or custom metadata.
  */
 export class UpdateOrderDataTool implements LuaTool {
-    name = "update_order_data";
-    description = "Update custom data on an order (tracking info, notes, etc.)";
-    inputSchema = z.object({
-        orderId: z.string().describe("The order ID to update"),
-        data: z.record(z.any()).describe("Custom data to add/update on the order")
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        console.log(`📝 Updating order ${input.orderId} with data:`, input.data);
-        
-        const result = await Orders.updateData(input.data, input.orderId);
-        
-        return {
-            success: true,
-            orderId: input.orderId,
-            message: "Order data updated successfully",
-            updatedData: input.data
-        };
-    }
+  name = 'update_order_data';
+  description = 'Update custom data on an order (tracking info, notes, etc.)';
+  inputSchema = z.object({
+    orderId: z.string().describe('The order ID to update'),
+    data: z.record(z.any()).describe('Custom data to add/update on the order'),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    console.log(`📝 Updating order ${input.orderId} with data:`, input.data);
+
+    const result = await Orders.updateData(input.data, input.orderId);
+
+    return {
+      success: true,
+      orderId: input.orderId,
+      message: 'Order data updated successfully',
+      updatedData: input.data,
+    };
+  }
 }