@nexttylabs/echo 0.2.0

package/lib/services/ai/classifier.ts

@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * 基于关键词的反馈自动分类
+ * MVP 实现：使用简单的关键词匹配
+ */
+
+export type FeedbackType = "bug" | "feature" | "issue" | "other";
+export type FeedbackPriority = "low" | "medium" | "high";
+
+const BUG_KEYWORDS = [
+  // 中文
+  "崩溃",
+  "错误",
+  "无法",
+  "失败",
+  "异常",
+  "故障",
+  "不能",
+  "不工作",
+  "没反应",
+  "卡住",
+  "卡死",
+  "闪退",
+  "黑屏",
+  "白屏",
+  "显示错误",
+  "报错",
+  "无法访问",
+  "无法登录",
+  "无法打开",
+  "无法加载",
+  "无法保存",
+  "无法提交",
+  // 英文
+  "bug",
+  "crash",
+  "error",
+  "broken",
+  "fail",
+  "failure",
+  "not working",
+  "doesn't work",
+  "unable to",
+  "cannot",
+  "exception",
+  "freeze",
+  "stuck",
+  "blank",
+  "glitch",
+];
+
+const FEATURE_KEYWORDS = [
+  // 中文
+  "希望",
+  "建议",
+  "添加",
+  "增加",
+  "新增",
+  "功能",
+  "改进",
+  "优化",
+  "增强",
+  "支持",
+  "能否",
+  "可以",
+  "最好",
+  "如果",
+  "愿望",
+  "期待",
+  "想要",
+  "需要",
+  // 英文
+  "feature",
+  "add",
+  "improve",
+  "enhance",
+  "suggest",
+  "wish",
+  "would like",
+  "request",
+  "support",
+  "implement",
+];
+
+const ISSUE_KEYWORDS = [
+  // 中文
+  "问题",
+  "疑问",
+  "困惑",
+  "不清楚",
+  "不知道",
+  "如何",
+  "怎么",
+  "怎样",
+  "咨询",
+  "问",
+  "求助",
+  // 英文
+  "issue",
+  "question",
+  "help",
+  "how to",
+  "confused",
+  "unclear",
+  "problem",
+  "trouble",
+];
+
+const HIGH_PRIORITY_KEYWORDS = [
+  // 中文
+  "紧急",
+  "严重",
+  "重要",
+  "关键",
+  "无法使用",
+  "完全不能",
+  "影响",
+  "阻塞",
+  "阻碍",
+  "核心",
+  "主要",
+  // 英文
+  "urgent",
+  "critical",
+  "severe",
+  "important",
+  "blocking",
+  "major",
+  "cannot use",
+  "unable to work",
+];
+
+const LOW_PRIORITY_KEYWORDS = [
+  // 中文
+  "建议",
+  "可选",
+  "也许",
+  "可能",
+  "或者",
+  "轻微",
+  "小",
+  "次要",
+  "非紧急",
+  "不急",
+  // 英文
+  "suggestion",
+  "optional",
+  "minor",
+  "nice to have",
+  "low",
+  "not urgent",
+  "whenever",
+  "eventually",
+];
+
+function normalizeText(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s\u4e00-\u9fa5]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function calculateScore(text: string, keywords: string[]): number {
+  const normalized = normalizeText(text);
+  const words = normalized.split(" ");
+
+  let score = 0;
+  for (const keyword of keywords) {
+    const normalizedKeyword = keyword.toLowerCase();
+    if (normalized.includes(normalizedKeyword)) {
+      score += 2;
+    }
+    for (const word of words) {
+      if (
+        word.includes(normalizedKeyword) ||
+        normalizedKeyword.includes(word)
+      ) {
+        score += 0.5;
+      }
+    }
+  }
+
+  return score;
+}
+
+export function classifyType(title: string, description?: string): FeedbackType {
+  const text = `${title} ${description || ""}`;
+
+  const bugScore = calculateScore(text, BUG_KEYWORDS);
+  const featureScore = calculateScore(text, FEATURE_KEYWORDS);
+  const issueScore = calculateScore(text, ISSUE_KEYWORDS);
+
+  if (bugScore > featureScore && bugScore > issueScore) {
+    return "bug";
+  } else if (featureScore > bugScore && featureScore > issueScore) {
+    return "feature";
+  } else if (issueScore > bugScore && issueScore > featureScore) {
+    return "issue";
+  }
+
+  return "other";
+}
+
+export function classifyPriority(
+  title: string,
+  description?: string,
+): FeedbackPriority {
+  const text = `${title} ${description || ""}`;
+
+  const highScore = calculateScore(text, HIGH_PRIORITY_KEYWORDS);
+  const lowScore = calculateScore(text, LOW_PRIORITY_KEYWORDS);
+
+  if (highScore > 0 && highScore > lowScore * 2) {
+    return "high";
+  } else if (lowScore > 0 && lowScore > highScore * 2) {
+    return "low";
+  }
+
+  return "medium";
+}
+
+export interface ClassificationResult {
+  type: FeedbackType;
+  priority: FeedbackPriority;
+  confidence: number;
+  reasons: string[];
+}
+
+export function classifyFeedback(
+  title: string,
+  description?: string,
+): ClassificationResult {
+  const text = `${title} ${description || ""}`;
+  const normalized = normalizeText(text);
+
+  const type = classifyType(title, description);
+  const priority = classifyPriority(title, description);
+
+  const keywords =
+    type === "bug"
+      ? BUG_KEYWORDS
+      : type === "feature"
+        ? FEATURE_KEYWORDS
+        : type === "issue"
+          ? ISSUE_KEYWORDS
+          : [];
+
+  const confidence =
+    keywords.length > 0
+      ? Math.min(calculateScore(text, keywords) / keywords.length, 1)
+      : 0;
+
+  const reasons: string[] = [];
+  for (const keyword of keywords) {
+    if (normalized.includes(keyword.toLowerCase())) {
+      reasons.push(`Matched keyword: "${keyword}"`);
+    }
+  }
+
+  return {
+    type,
+    priority,
+    confidence: Math.round(confidence * 100) / 100,
+    reasons: reasons.slice(0, 3),
+  };
+}
+
+export async function batchClassifyFeedback(
+  feedbacks: Array<{
+    feedbackId: string;
+    title: string;
+    description?: string;
+  }>,
+): Promise<Array<{ feedbackId: string; classification: ClassificationResult }>> {
+  return feedbacks.map((feedback) => ({
+    feedbackId: feedback.feedbackId,
+    classification: classifyFeedback(feedback.title, feedback.description),
+  }));
+}

package/lib/services/ai/duplicate-detector.ts

@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * 重复反馈检测服务
+ * 使用 Levenshtein 距离和关键词重叠算法检测重复
+ */
+
+export interface DuplicateCandidate {
+  feedbackId: number;
+  title: string;
+  description: string;
+  similarity: number;
+  reasons: string[];
+}
+
+/**
+ * Levenshtein 距离算法（字符串相似度）
+ */
+function levenshteinDistance(str1: string, str2: string): number {
+  const len1 = str1.length;
+  const len2 = str2.length;
+  const matrix: number[][] = [];
+
+  for (let i = 0; i <= len1; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= len2; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= len1; i++) {
+    for (let j = 1; j <= len2; j++) {
+      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost,
+      );
+    }
+  }
+
+  return matrix[len1][len2];
+}
+
+/**
+ * 计算字符串相似度（0-1）
+ */
+function stringSimilarity(str1: string, str2: string): number {
+  const len1 = str1.length;
+  const len2 = str2.length;
+  const maxLen = Math.max(len1, len2);
+
+  if (maxLen === 0) return 1;
+
+  const distance = levenshteinDistance(str1.toLowerCase(), str2.toLowerCase());
+  return 1 - distance / maxLen;
+}
+
+const STOP_WORDS = new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "as",
+  "is",
+  "was",
+  "are",
+  "were",
+  "的",
+  "了",
+  "是",
+  "在",
+  "和",
+  "或",
+  "但是",
+  "从",
+  "为了",
+  "关于",
+]);
+
+/**
+ * 提取关键词（移除停用词）
+ */
+function extractKeywords(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s\u4e00-\u9fa5]/g, " ")
+    .split(/\s+/)
+    .filter((word) => word.length > 2 && !STOP_WORDS.has(word));
+}
+
+/**
+ * 计算关键词重叠度 (Jaccard similarity)
+ */
+function keywordOverlap(text1: string, text2: string): number {
+  const keywords1 = new Set(extractKeywords(text1));
+  const keywords2 = new Set(extractKeywords(text2));
+
+  if (keywords1.size === 0 && keywords2.size === 0) return 0;
+
+  const intersection = new Set([...keywords1].filter((x) => keywords2.has(x)));
+  const union = new Set([...keywords1, ...keywords2]);
+
+  return intersection.size / union.size;
+}
+
+/**
+ * 计算综合相似度
+ */
+export function calculateSimilarity(
+  title1: string,
+  desc1: string,
+  title2: string,
+  desc2: string,
+): { score: number; reasons: string[] } {
+  const reasons: string[] = [];
+  let totalScore = 0;
+  let weightSum = 0;
+
+  // 标题相似度（权重 50%）
+  const titleSimilarity = stringSimilarity(title1, title2);
+  totalScore += titleSimilarity * 50;
+  weightSum += 50;
+
+  if (titleSimilarity > 0.8) {
+    reasons.push(
+      `Titles are very similar (${Math.round(titleSimilarity * 100)}%)`,
+    );
+  }
+
+  // 描述相似度（权重 30%）
+  const descSimilarity = stringSimilarity(desc1 || "", desc2 || "");
+  totalScore += descSimilarity * 30;
+  weightSum += 30;
+
+  if (descSimilarity > 0.7) {
+    reasons.push(
+      `Descriptions are similar (${Math.round(descSimilarity * 100)}%)`,
+    );
+  }
+
+  // 关键词重叠度（权重 20%）
+  const fullText1 = `${title1} ${desc1 || ""}`;
+  const fullText2 = `${title2} ${desc2 || ""}`;
+  const keywordScore = keywordOverlap(fullText1, fullText2);
+  totalScore += keywordScore * 20;
+  weightSum += 20;
+
+  if (keywordScore > 0.5) {
+    reasons.push(
+      `Many keywords in common (${Math.round(keywordScore * 100)}%)`,
+    );
+  }
+
+  const finalScore = weightSum > 0 ? totalScore / weightSum : 0;
+
+  return {
+    score: Math.round(finalScore * 100) / 100,
+    reasons,
+  };
+}
+
+export interface FeedbackForDuplicateCheck {
+  feedbackId: number;
+  title: string;
+  description: string | null;
+}
+
+/**
+ * 检测与现有反馈的重复
+ */
+export function findDuplicates(
+  title: string,
+  description: string | undefined,
+  existingFeedbacks: FeedbackForDuplicateCheck[],
+  excludeFeedbackId?: number,
+  threshold: number = 0.75,
+): DuplicateCandidate[] {
+  const candidates: DuplicateCandidate[] = [];
+
+  for (const existing of existingFeedbacks) {
+    if (excludeFeedbackId && existing.feedbackId === excludeFeedbackId) {
+      continue;
+    }
+
+    const { score, reasons } = calculateSimilarity(
+      title,
+      description || "",
+      existing.title,
+      existing.description || "",
+    );
+
+    if (score >= threshold) {
+      candidates.push({
+        feedbackId: existing.feedbackId,
+        title: existing.title,
+        description: existing.description || "",
+        similarity: Math.round(score * 100),
+        reasons,
+      });
+    }
+  }
+
+  return candidates.sort((a, b) => b.similarity - a.similarity);
+}
+
+/**
+ * 批量检测重复
+ */
+export function batchFindDuplicates(
+  feedbacks: Array<{
+    feedbackId: number;
+    title: string;
+    description?: string;
+  }>,
+  allFeedbacks: FeedbackForDuplicateCheck[],
+  threshold: number = 0.75,
+): Array<{ feedbackId: number; duplicates: DuplicateCandidate[] }> {
+  return feedbacks.map((fb) => ({
+    feedbackId: fb.feedbackId,
+    duplicates: findDuplicates(
+      fb.title,
+      fb.description,
+      allFeedbacks,
+      fb.feedbackId,
+      threshold,
+    ),
+  }));
+}

package/lib/services/ai/tag-suggester.ts

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { PREDEFINED_TAGS } from "@/lib/db/schema/tags";
+
+export interface TagSuggestion {
+  name: string;
+  slug: string;
+  confidence: number;
+  matchedKeywords: string[];
+}
+
+function normalizeText(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s\u4e00-\u9fa5]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function calculateTagScore(
+  text: string,
+  tag: (typeof PREDEFINED_TAGS)[number],
+): {
+  score: number;
+  matchedKeywords: string[];
+} {
+  const normalized = normalizeText(text);
+  const words = normalized.split(" ");
+
+  let score = 0;
+  const matchedKeywords: string[] = [];
+
+  for (const keyword of tag.keywords) {
+    const normalizedKeyword = keyword.toLowerCase();
+
+    if (normalized.includes(normalizedKeyword)) {
+      score += 3;
+      matchedKeywords.push(keyword);
+    }
+
+    for (const word of words) {
+      if (
+        word === normalizedKeyword ||
+        word.includes(normalizedKeyword) ||
+        normalizedKeyword.includes(word)
+      ) {
+        score += 1;
+        if (!matchedKeywords.includes(keyword)) {
+          matchedKeywords.push(keyword);
+        }
+      }
+    }
+  }
+
+  return { score, matchedKeywords };
+}
+
+export function suggestTags(
+  title: string,
+  description?: string,
+  maxSuggestions: number = 5,
+): TagSuggestion[] {
+  const text = `${title} ${description || ""}`;
+
+  const tagScores = PREDEFINED_TAGS.map((tag) => {
+    const { score, matchedKeywords } = calculateTagScore(text, tag);
+    return {
+      name: tag.name,
+      slug: tag.slug,
+      confidence: Math.min(score / 5, 1),
+      matchedKeywords,
+    };
+  });
+
+  const filtered = tagScores.filter((tag) => tag.confidence > 0);
+
+  return filtered
+    .sort((a, b) => b.confidence - a.confidence)
+    .slice(0, maxSuggestions);
+}
+
+export async function batchSuggestTags(
+  feedbacks: Array<{
+    feedbackId: string;
+    title: string;
+    description?: string;
+  }>,
+): Promise<Array<{ feedbackId: string; suggestions: TagSuggestion[] }>> {
+  return feedbacks.map((feedback) => ({
+    feedbackId: feedback.feedbackId,
+    suggestions: suggestTags(feedback.title, feedback.description),
+  }));
+}