@mseep/ai-tech-app-agent 1.0.0

package/src/llm/llamaClient.ts

@@ -0,0 +1,159 @@
+import axios, { AxiosInstance } from 'axios';
+import dotenv from 'dotenv';
+import logger from '../utils/logger';
+import { ActionPlan } from '../models/testSpec';
+
+dotenv.config();
+
+export class LlamaClient {
+  private client: AxiosInstance;
+  private model: string;
+  private temperature: number;
+  private maxTokens: number;
+
+  constructor() {
+    const baseURL = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+    this.model = process.env.LLM_MODEL || 'llama3.2:3b';
+    this.temperature = parseFloat(process.env.LLM_TEMPERATURE || '0.1');
+    this.maxTokens = parseInt(process.env.LLM_MAX_TOKENS || '2000');
+
+    this.client = axios.create({
+      baseURL,
+      timeout: 60000,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    logger.info(`LlamaClient initialized with model: ${this.model}`);
+  }
+
+  async generateActionPlan(
+    stepText: string,
+    uiContext: string,
+    appKnowledge?: string
+  ): Promise<ActionPlan> {
+    const prompt = this.buildPrompt(stepText, uiContext, appKnowledge);
+
+    try {
+      logger.debug(`Sending prompt to LLM for step: "${stepText}"`);
+
+      const response = await this.client.post('/api/generate', {
+        model: this.model,
+        prompt,
+        stream: false,
+        options: {
+          temperature: this.temperature,
+          num_predict: this.maxTokens,
+        },
+        format: 'json', // Request JSON output
+      });
+
+      const rawResponse = response.data.response;
+      logger.debug(`LLM raw response: ${rawResponse}`);
+
+      // Parse the JSON response
+      const actionPlan = this.parseActionPlan(rawResponse);
+      logger.info(`Generated ${actionPlan.actions.length} actions for step`);
+
+      return actionPlan;
+    } catch (error: any) {
+      logger.error(`Error generating action plan: ${error.message}`);
+      throw new Error(`LLM generation failed: ${error.message}`);
+    }
+  }
+
+  private buildPrompt(
+    stepText: string,
+    uiContext: string,
+    appKnowledge?: string
+  ): string {
+    return `You are an expert mobile test automation agent. Your task is to generate precise Appium actions to accomplish a test step.
+
+**App Context:**
+${appKnowledge || 'A mobile application with standard Android/iOS UI patterns.'}
+
+**Current UI State:**
+${uiContext}
+
+**Test Step to Execute:**
+"${stepText}"
+
+**Instructions:**
+1. Analyze the current UI state carefully
+2. Identify the most reliable element selectors (prefer text, accessibility-id, or resource-id over XPath)
+3. Generate a sequence of actions to accomplish the test step
+4. Minimize screenshot-based coordinate selection - use it only as last resort
+5. Ensure actions are reliable across different device sizes
+
+**Output Format (JSON only, no markdown):**
+{
+  "actions": [
+    {
+      "type": "tap|type|scroll|swipe|wait|assert",
+      "selector": {
+        "strategy": "text|id|accessibility-id|xpath|class",
+        "value": "selector_value",
+        "index": 0
+      },
+      "value": "text_to_type (only for type action)",
+      "direction": "up|down|left|right (only for scroll/swipe)",
+      "assertionType": "exists|visible|text|enabled (only for assert)",
+      "expectedValue": "expected_value (only for assert)"
+    }
+  ],
+  "reasoning": "Brief explanation of the action sequence"
+}
+
+Generate the JSON action plan now:`;
+  }
+
+  private parseActionPlan(rawResponse: string): ActionPlan {
+    try {
+      // Remove any markdown code blocks if present
+      let cleanedResponse = rawResponse
+        .replace(/```json\n?/g, '')
+        .replace(/```\n?/g, '')
+        .trim();
+
+      const parsed = JSON.parse(cleanedResponse);
+
+      // Validate the structure
+      if (!parsed.actions || !Array.isArray(parsed.actions)) {
+        throw new Error('Invalid action plan structure: missing actions array');
+      }
+
+      return parsed as ActionPlan;
+    } catch (error: any) {
+      logger.error(`Failed to parse action plan: ${error.message}`);
+      logger.error(`Raw response: ${rawResponse}`);
+
+      // Return a fallback empty action plan
+      return {
+        actions: [],
+        reasoning: `Parsing failed: ${error.message}`,
+      };
+    }
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const response = await this.client.get('/api/tags');
+      const models = response.data.models || [];
+      const modelExists = models.some((m: any) => m.name === this.model);
+
+      if (!modelExists) {
+        logger.warn(`Model ${this.model} not found in Ollama. Available models: ${models.map((m: any) => m.name).join(', ')}`);
+        return false;
+      }
+
+      logger.info('LLM health check passed');
+      return true;
+    } catch (error: any) {
+      logger.error(`LLM health check failed: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+export default LlamaClient;