npm init -y
npm install typescript @types/node --save-dev
npm install natural uuid

npx tsc --init

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

import { v4 as uuidv4 } from 'uuid';

type Intent = {
  name: string;
  confidence: number;
};

type Context = {
  [key: string]: any;
};

type Message = {
  id: string;
  text: string;
  timestamp: Date;
};

export class Assistant {
  private context: Context = {};
  private conversationHistory: Message[] = [];

  constructor(public name: string) {}

  // 添加消息到对话历史
  private addMessage(text: string): Message {
    const message: Message = {
      id: uuidv4(),
      text,
      timestamp: new Date()
    };
    this.conversationHistory.push(message);
    return message;
  }

  // 处理用户输入的核心方法
  public async processInput(userInput: string): Promise<string> {
    const userMessage = this.addMessage(userInput);

    // Step1: 意图识别
    const intent = await this.recognizeIntent(userInput);

    // Step2: 更新上下文
    this.updateContext(intent, userInput);

    // Step3: 生成响应
    const response = await this.generateResponse(intent);

    this.addMessage(response);

    return response;
  }

  // TODO: Implement these methods in subclasses or extensions
 protected async recognizeIntent(text: string): Promise<Intent> {
   throw new Error('Method not implemented.');
 }

 protected updateContext(intent: Intent, text: string): void {
   throw new Error('Method not implemented.');
 }

 protected async generateResponse(intent: Intent): Promise<string> {
   throw new Error('Method not implemented.');
 }
}

npm install natural @types/natural

import { WordTokenizer, PorterStemmer } from 'natural';
import { Assistant, Intent } from '../core/Assistant';

export class NLPProcessor extends Assistant {
 private tokenizer = new WordTokenizer();
 private keywordsMap: { [key: string]: string[] } = {
   greeting: ['hello', 'hi', 'hey'],
   weather: ['weather', 'forecast', 'temperature'],
   goodbye: ['bye', 'goodbye', 'see you']
 };

 protected async recognizeIntent(text: string): Promise<Intent> {
   const tokens = this.tokenizer.tokenize(text.toLowerCase()) || [];
   const stemmedTokens = tokens.map(token => PorterStemmer.stem(token));

   let bestMatch = { name: 'unknown', confidence: 0 };

   for (const [intent, keywords] of Object.entries(this.keywordsMap)) {
     const matches = stemmedTokens.filter(token => 
       keywords.some(keyword => keyword === token)
     );

     const confidence = matches.length / keywords.length;

     if (confidence > bestMatch.confidence) {
       bestMatch = { name: intent, confidence };
     }
   }

   return bestMatch;
 }

 protected async generateResponse(intent: Intent): Promise<string> {
   switch (intent.name) {
     case 'greeting':
       return `Hello! I'm ${this.name}. How can I help you today?`;
     case 'weather':
       return `I can check the weather for you. What location are you interested in?`;
     case 'goodbye':
       return `Goodbye! Have a great day!`;
     default:
       return `I'm not sure I understand. Could you rephrase that?`;
   }
 }

 protected updateContext(intent: Intent, text: string): void {
   if (intent.name === 'weather') {
     // Extract location from text if available
     const locationRegex = /(in|at|for)\s+([a-zA-Z]+)/i;
     const match = text.match(locationRegex);

     if (match && match[2]) {
       this.context.location = match[2];
     }
   }
 }
}

import { NLPProcessor } from './nlp/NLPProcessor';

async function main() {
 console.log('Initializing smart assistant...');

 const assistant = new NLPProcessor('GuideBot');

 // Test conversation flow
 const testInputs = [
   "Hello there!",
   "What's the weather like today?",
   "In New York",
   "Thank you, goodbye!"
 ];

 for (const input of testInputs) {
   console.log(`User: ${input}`);
   const response = await assistant.processInput(input);
   console.log(`Bot : ${response}`);
 }
}

main().catch(console.error);

npx tsc && node dist/index.js

import fs from 'fs';
import path from 'path';

export class PersistentAssistant extends Assistant {
 private storagePath: string;

 constructor(name: string, storagePath?: string) {
   super(name);
   this.storagePath = storagePath || path.join(__dirname, `${name}-context.json`);

   try {
     const data = fs.readFileSync(this.storagePath, 'utf8');
     this.context = JSON.parse(data);
   } catch (err) {
     this.context = {};
   }
 }

 public saveContext(): void {
   fs.writeFileSync(
     this.storagePath,
     JSON.stringify(this.context, null, 2),
     'utf8'
   );
 }

 public async processInput(userInput: string): Promise<string> {
   const response = await super.processInput(userInput);
   this.saveContext();

   return response;
 }
}