aitable-workflow-cli 0.1.15 → 0.1.16-beta.1786022310508

package/templates/support-qa/lib/troubleshoot.ts

@@ -1,236 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
-
-/**
- * troubleshoot 声明式分类器引擎（support-qa L3，场景层，零 core 依赖）
- *
- * 取代 aitable-handoff 硬编码的 issue-classifier.ts：把「命中哪种问题类型」从代码正则
- * 收敛为 profile/troubleshoot/classifiers.yml 的声明式规则。每个分类器：
- *   - issueType：命中后的问题类型标签（如 ai_field / data_source）；
- *   - module   ：可选，命中后透传给下游的 Owner 模块名（必须是 owner-map.json 精确 key）；
- *     未定位异常据此路由到模块 Owner，不再固定输出空 module；
- *   - patterns ：匹配条件列表，每条 contains|regex；
- *   - require_all：默认 false（任一命中）；true 时需全部命中（如数据源问题需
- *                  docKey + 时间戳 同时存在）；
- *   - extract  ：可选，字段名→正则（取第一个捕获组），把结构化证据带进排查 prompt。
- *
- * 分类结果为 null 表示「未命中确定性排查规则」→ 交给语义答疑 answer。
- *
- * 整档开关（gate）：
- *   - profile.troubleshoot.skills_dir 未配置或该目录不存在 → 整档关闭（isTroubleshootEnabled=false）；
- *   - 按群开关：群配置表 troubleshootingEnabled 明确为真才对该群启用（isGroupTroubleshootingEnabled）。
- */
-
-const troubleshootPatternSchema = z.object({
-  contains: z.string().optional(),
-  regex: z.string().optional(),
-}).refine(
-  (p) => Boolean(p.contains?.trim()) !== Boolean(p.regex?.trim()),
-  { message: "必须且只能有 contains/regex 之一" },
-);
-
-export const classifiersSchema = z.object({
-  classifiers: z.array(z.object({
-    issueType: z.string().min(1),
-    reason: z.string().optional(),
-    patterns: z.array(troubleshootPatternSchema).min(1),
-    require_all: z.boolean().optional(),
-    extract: z.record(z.string(), z.string()).optional(),
-  })),
-});
-
-export type TroubleshootPattern = { contains?: string; regex?: string; compiledRegex?: RegExp };
-
-export type ClassifierDef = {
-  issueType: string;
-  /** 可选：Owner 路由模块名（owner-map.json 精确 key），命中时透传到分类结果 */
-  module?: string;
-  reason: string;
-  patterns: TroubleshootPattern[];
-  requireAll: boolean;
-  /** 字段名 → 正则（取第一个捕获组）；未命中该字段填 null */
-  extract: Record<string, string>;
-};
-
-export type TroubleshootConfig = { classifiers: ClassifierDef[] };
-
-export type ClassifyResult = {
-  issueType: string;
-  module?: string;
-  reason: string;
-  extracted: Record<string, string | null>;
-};
-
-export type TroubleshootLoadResult = {
-  /** null = 未配置或文件缺失/无有效分类器（交给 answer） */
-  config: TroubleshootConfig | null;
-  issues: string[];
-};
-
-const cache = new Map<string, TroubleshootLoadResult>();
-
-/** 加载并校验分类器；按解析后的绝对路径缓存 */
-export function loadClassifiers(configDir: string, classifiersRel: string | undefined): TroubleshootLoadResult {
-  const rel = String(classifiersRel ?? "").trim();
-  if (!rel) return { config: null, issues: [] };
-  const abs = path.resolve(configDir, "profile", rel);
-  const hit = cache.get(abs);
-  if (hit) return hit;
-
-  let res: TroubleshootLoadResult;
-  if (!existsSync(abs)) {
-    res = { config: null, issues: [`troubleshoot.classifiers 引用的文件不存在: profile/${rel}`] };
-  } else {
-    try {
-      const raw = (parseYaml(readFileSync(abs, "utf8")) ?? {}) as Record<string, unknown>;
-      const issues: string[] = [];
-      const classifiers = normalizeClassifiers(raw, issues);
-      res = { config: classifiers.length > 0 ? { classifiers } : null, issues };
-    } catch (err) {
-      res = { config: null, issues: [`troubleshoot 分类器解析失败 profile/${rel}: ${err instanceof Error ? err.message : String(err)}`] };
-    }
-  }
-  cache.set(abs, res);
-  return res;
-}
-
-function normalizeClassifiers(raw: Record<string, unknown>, issues: string[]): ClassifierDef[] {
-  const out: ClassifierDef[] = [];
-  const rawList = Array.isArray(raw.classifiers) ? raw.classifiers : [];
-  for (let i = 0; i < rawList.length; i++) {
-    const c = rawList[i] as Record<string, unknown> | null;
-    if (!c || typeof c !== "object") {
-      issues.push(`classifiers[${i}] 不是对象`);
-      continue;
-    }
-    const issueType = String(c.issueType ?? "").trim();
-    if (!issueType) {
-      issues.push(`classifiers[${i}] 缺少 issueType`);
-      continue;
-    }
-    const patterns = normalizePatterns(c.patterns, issueType, issues);
-    if (patterns.length === 0) {
-      issues.push(`classifiers[${issueType}] 无有效 patterns`);
-      continue;
-    }
-    const extract: Record<string, string> = {};
-    const rawExtract = c.extract as Record<string, unknown> | undefined;
-    if (rawExtract && typeof rawExtract === "object") {
-      for (const [field, rx] of Object.entries(rawExtract)) {
-        const pattern = String(rx ?? "");
-        try {
-          new RegExp(pattern);
-          extract[field] = pattern;
-        } catch {
-          issues.push(`classifiers[${issueType}].extract.${field} 非法正则: ${pattern}`);
-        }
-      }
-    }
-    out.push({
-      issueType,
-      ...(String(c.module ?? "").trim() ? { module: String(c.module).trim() } : {}),
-      reason: String(c.reason ?? `命中 ${issueType} 分类规则`).trim(),
-      patterns,
-      requireAll: c.require_all === true,
-      extract,
-    });
-  }
-  return out;
-}
-
-function normalizePatterns(raw: unknown, issueType: string, issues: string[]): TroubleshootPattern[] {
-  const out: TroubleshootPattern[] = [];
-  for (const p of Array.isArray(raw) ? raw : []) {
-    if (!p || typeof p !== "object") continue;
-    const rec = p as Record<string, unknown>;
-    const hasContains = typeof rec.contains === "string" && rec.contains.trim();
-    const hasRegex = typeof rec.regex === "string" && String(rec.regex).trim();
-    if (Boolean(hasContains) === Boolean(hasRegex)) {
-      issues.push(`classifiers[${issueType}] 每条 pattern 必须且只能有 contains/regex 之一`);
-      continue;
-    }
-    if (hasContains) {
-      out.push({ contains: String(rec.contains) });
-    } else {
-      const rx = String(rec.regex);
-      try {
-        out.push({ regex: rx, compiledRegex: new RegExp(rx) });
-      } catch {
-        issues.push(`classifiers[${issueType}] 非法正则: ${rx}`);
-      }
-    }
-  }
-  return out;
-}
-
-function testPattern(p: TroubleshootPattern, message: string): boolean {
-  if (p.contains !== undefined) return message.includes(p.contains);
-  if (p.compiledRegex) return p.compiledRegex.test(message);
-  return false;
-}
-
-function extractFields(extract: Record<string, string>, message: string): Record<string, string | null> {
-  const out: Record<string, string | null> = {};
-  for (const [field, rx] of Object.entries(extract)) {
-    try {
-      const m = message.match(new RegExp(rx));
-      out[field] = m?.[1] ?? m?.[0] ?? null;
-    } catch {
-      out[field] = null;
-    }
-  }
-  return out;
-}
-
-/**
- * 分类当前消息：按声明顺序返回第一个满足的分类器（require_all→全部 pattern 命中；否则任一命中）。
- * 无命中返回 null（交语义答疑 answer）。
- */
-export function classifyIssue(config: TroubleshootConfig | null, message: string): ClassifyResult | null {
-  if (!config) return null;
-  const msg = message ?? "";
-  if (!msg.trim()) return null;
-  for (const c of config.classifiers) {
-    const ok = c.requireAll
-      ? c.patterns.every((p) => testPattern(p, msg))
-      : c.patterns.some((p) => testPattern(p, msg));
-    if (ok) {
-      return {
-        issueType: c.issueType,
-        ...(c.module ? { module: c.module } : {}),
-        reason: c.reason,
-        extracted: extractFields(c.extract, msg),
-      };
-    }
-  }
-  return null;
-}
-
-// ─── 整档开关 ────────────────────────────────────────────
-
-/**
- * troubleshoot 是否整档启用：profile.troubleshoot.skills_dir 已配置且该目录存在。
- * skills_dir 相对实例根解析；未配置或目录缺失 → 整档关闭（spec §8）。
- */
-export function isTroubleshootEnabled(configDir: string, skillsDir: string | undefined): boolean {
-  const rel = String(skillsDir ?? "").trim();
-  if (!rel) return false;
-  return existsSync(path.resolve(configDir, rel));
-}
-
-type GroupConfig = { groupId?: unknown; troubleshootingEnabled?: unknown };
-const TRUE_VALUES = new Set(["true", "1", "yes", "on", "是", "开启", "启用", "已勾选"]);
-
-function explicitTrue(value: unknown): boolean {
-  if (value === true || value === 1) return true;
-  return typeof value === "string" && TRUE_VALUES.has(value.trim().toLowerCase());
-}
-
-/** 仅当来源群明确开启排查时启用；群缺失、字段缺失、未知值都默认关闭（继承 handoff 语义）。 */
-export function isGroupTroubleshootingEnabled(raw: unknown, conversationId: string): boolean {
-  if (!conversationId || !Array.isArray(raw)) return false;
-  const group = (raw as GroupConfig[]).find((g) => String(g?.groupId ?? "").trim() === conversationId);
-  return explicitTrue(group?.troubleshootingEnabled);
-}