homeassistant-mcp/src/ai/nlp/intent-classifier.ts

interface ClassifiedIntent {
  action: string;
  target: string;
  confidence: number;
  parameters: Record<string, any>;
  raw_input: string;
}

interface ActionPattern {
  action: string;
  patterns: RegExp[];
  parameters?: string[];
}

export class IntentClassifier {
  private actionPatterns: ActionPattern[];

  constructor() {
    this.actionPatterns = [
      {
        action: "turn_on",
        patterns: [/turn\s+on/i, /switch\s+on/i, /enable/i, /activate/i],
      },
      {
        action: "turn_off",
        patterns: [/turn\s+off/i, /switch\s+off/i, /disable/i, /deactivate/i],
      },
      {
        action: "set",
        patterns: [
          /set\s+(?:the\s+)?(.+)\s+to/i,
          /change\s+(?:the\s+)?(.+)\s+to/i,
          /adjust\s+(?:the\s+)?(.+)\s+to/i,
        ],
        parameters: ["brightness", "temperature", "color"],
      },
      {
        action: "query",
        patterns: [
          /what\s+is/i,
          /get\s+(?:the\s+)?(.+)/i,
          /show\s+(?:the\s+)?(.+)/i,
          /tell\s+me/i,
        ],
      },
    ];
  }

  async classify(
    input: string,
    extractedEntities: {
      parameters: Record<string, any>;
      primary_target: string;
    },
  ): Promise<ClassifiedIntent> {
    let bestMatch: ClassifiedIntent = {
      action: "",
      target: "",
      confidence: 0,
      parameters: {},
      raw_input: input,
    };

    for (const actionPattern of this.actionPatterns) {
      for (const pattern of actionPattern.patterns) {
        const match = input.match(pattern);
        if (match) {
          const confidence = this.calculateConfidence(match[0], input);
          if (confidence > bestMatch.confidence) {
            bestMatch = {
              action: actionPattern.action,
              target: extractedEntities.primary_target,
              confidence,
              parameters: this.extractActionParameters(
                actionPattern,
                match,
                extractedEntities,
              ),
              raw_input: input,
            };
          }
        }
      }
    }

    // If no match found, try to infer from context
    if (!bestMatch.action) {
      bestMatch = this.inferFromContext(input, extractedEntities);
    }

    return bestMatch;
  }

  private calculateConfidence(match: string, input: string): number {
    // Base confidence from match length relative to input length
    const lengthRatio = match.length / input.length;
    let confidence = lengthRatio * 0.7;

    // Boost confidence for exact matches
    if (match.toLowerCase() === input.toLowerCase()) {
      confidence += 0.3;
    }

    // Additional confidence for specific keywords
    const keywords = ["please", "can you", "would you"];
    for (const keyword of keywords) {
      if (input.toLowerCase().includes(keyword)) {
        confidence += 0.1;
      }
    }

    return Math.min(1, confidence);
  }

  private extractActionParameters(
    actionPattern: ActionPattern,
    match: RegExpMatchArray,
    extractedEntities: {
      parameters: Record<string, any>;
      primary_target: string;
    },
  ): Record<string, any> {
    const parameters: Record<string, any> = {};

    // Copy relevant extracted entities
    if (actionPattern.parameters) {
      for (const param of actionPattern.parameters) {
        if (extractedEntities.parameters[param] !== undefined) {
          parameters[param] = extractedEntities.parameters[param];
        }
      }
    }

    // Extract additional parameters from match groups
    if (match.length > 1 && match[1]) {
      parameters.raw_parameter = match[1].trim();
    }

    return parameters;
  }

  private inferFromContext(
    input: string,
    extractedEntities: {
      parameters: Record<string, any>;
      primary_target: string;
    },
  ): ClassifiedIntent {
    // Default to 'set' action if parameters are present
    if (Object.keys(extractedEntities.parameters).length > 0) {
      return {
        action: "set",
        target: extractedEntities.primary_target,
        confidence: 0.5,
        parameters: extractedEntities.parameters,
        raw_input: input,
      };
    }

    // Default to 'query' for question-like inputs
    if (input.match(/^(what|when|where|who|how|why)/i)) {
      return {
        action: "query",
        target: extractedEntities.primary_target || "system",
        confidence: 0.6,
        parameters: {},
        raw_input: input,
      };
    }

    // Fallback with low confidence
    return {
      action: "unknown",
      target: extractedEntities.primary_target || "system",
      confidence: 0.3,
      parameters: {},
      raw_input: input,
    };
  }
}