ex-brain 0.2.6 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ex-brain",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "CLI personal knowledge base powered by seekdb",
   "module": "src/cli.ts",
   "type": "module",
@@ -31,8 +31,10 @@
     "commander": "^14.0.3",
     "gray-matter": "^4.0.3",
     "jsonrepair": "^3.13.3",
+    "mammoth": "^1.12.0",
     "pinyin-pro": "^3.28.0",
     "seekdb": "^1.2.0",
+    "unpdf": "^1.6.2",
     "yaml": "^2.8.3",
     "zod": "^4.3.6"
   }

package/src/ai/ax-pipeline.ts

@@ -0,0 +1,114 @@
+/**
+ * AIPipeline — Deep module encapsulating the full LLM call lifecycle.
+ *
+ * Encapsulates: createAxAI → guard → forward → parse → transform → fallback.
+ * This eliminates boilerplate duplication across compiler.ts,
+ * timeline-extractor.ts, and entity-link.ts.
+ *
+ * Each existing AI module becomes pure configuration (signature + mapping
+ * functions) behind this deep interface.
+ */
+
+import { ax } from "@ax-llm/ax";
+import type { Signature } from "@ax-llm/ax";
+import type { ResolvedLLM } from "../settings";
+import { createAxAI } from "./ax-adapter";
+
+// ---------------------------------------------------------------------------
+// Pipeline definition
+// ---------------------------------------------------------------------------
+
+export interface AIPipelineOptions<TInput, TRaw, TResult> {
+  /** Ax Signature that defines input/output shape. */
+  signature: Signature;
+  /** Map domain input → Ax forward args. */
+  mapInput: (input: TInput) => Record<string, unknown>;
+  /** Extract the relevant field from raw Ax output before parsing. */
+  extractOutput?: (raw: Record<string, unknown>) => unknown;
+  /** Parse extracted output → structured intermediate. Return null on failure. */
+  parseRaw: (raw: unknown) => TRaw | null;
+  /** Transform parsed data + original input → final result. */
+  transform: (raw: TRaw, input: TInput) => TResult;
+  /** Fallback when LLM is unavailable or output is unparseable. */
+  fallback: (input: TInput) => TResult;
+  /** Log prefix for warnings (e.g. "Ax compilation"). */
+  label: string;
+}
+
+export class AIPipeline<TInput, TRaw, TResult> {
+  private gen: ReturnType<typeof ax>;
+
+  constructor(private opts: AIPipelineOptions<TInput, TRaw, TResult>) {
+    this.gen = ax(opts.signature);
+  }
+
+  /**
+   * Execute the full LLM call lifecycle.
+   * Returns fallback result if LLM is unavailable, forward fails,
+   * or output cannot be parsed.
+   */
+  async run(input: TInput, llm: ResolvedLLM): Promise<TResult> {
+    const ai = createAxAI(llm);
+    if (!ai) return this.opts.fallback(input);
+
+    try {
+      const mapped = this.opts.mapInput(input);
+      const result = await this.gen.forward(ai, mapped);
+      const extracted = this.opts.extractOutput
+        ? this.opts.extractOutput(result as Record<string, unknown>)
+        : result;
+      const raw = this.opts.parseRaw(extracted);
+      if (!raw) return this.opts.fallback(input);
+      return this.opts.transform(raw, input);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(`[ebrain] ${this.opts.label} failed, falling back: ${msg}`);
+      return this.opts.fallback(input);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// JSON parsing utilities (shared across pipelines)
+// ---------------------------------------------------------------------------
+
+/** Parse unknown → object, handling string-encoded JSON. */
+export function parseJsonObject(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw === "object" && raw !== null) return raw as Record<string, unknown>;
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw) as Record<string, unknown>; } catch { return null; }
+  }
+  return null;
+}
+
+/** Parse unknown → array, handling string-encoded JSON. */
+export function parseJsonArray<T = Record<string, unknown>>(raw: unknown): T[] | null {
+  if (Array.isArray(raw)) return raw as T[];
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw) as T[]; } catch { return null; }
+  }
+  return null;
+}
+
+/**
+ * Normalize field names using alias mapping.
+ * Accepts both English and Chinese LLM output variants.
+ *
+ * Example:
+ *   normalizeFields(item, { fromName: ['fromName', 'from_name', 'from', '来源'] })
+ */
+export function normalizeFields(
+  obj: Record<string, unknown>,
+  aliases: Record<string, string[]>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [canonical, aliasList] of Object.entries(aliases)) {
+    for (const alias of aliasList) {
+      if (obj[alias] !== undefined) {
+        result[canonical] = obj[alias];
+        break;
+      }
+    }
+  }
+  return result;
+}

package/src/ai/compiler.ts

@@ -1,20 +1,16 @@
 /**
- * Intelligent Compilation — Ax Signature version.
+ * Intelligent Compilation — AIPipeline version.
  *
- * Uses f.json() for complex multi-line output (compiledTruth contains markdown
- * with multiple lines, which breaks Ax's line-based field parsing).
+ * Uses AIPipeline for LLM call lifecycle (createAxAI → forward → parse → transform → fallback).
+ * Two pipeline instances: compileTruth + extractTimeline (both use AIPipeline).
  *
- * Features:
- * - Declaraive input/output contracts
- * - Automatic validation + retry on failure
- * - Ready for GEPA optimization
- * - Fallback to append when LLM unavailable
+ * Public API unchanged — drop-in replacement for callers.
  */
 
-import { ax, f } from "@ax-llm/ax";
+import { f } from "@ax-llm/ax";
 import type { ResolvedLLM } from "../settings";
 import type { TimelineEntry } from "../types";
-import { createAxAI } from "./ax-adapter";
+import { AIPipeline, parseJsonObject } from "./ax-pipeline";
 
 // ---------------------------------------------------------------------------
 // Types (preserved for API compatibility with BrainRepository)
@@ -39,7 +35,7 @@ export interface CompileResult {
 }
 
 // ---------------------------------------------------------------------------
-// Signature definition (using json for multi-line compiledTruth)
+// Compile pipeline configuration
 // ---------------------------------------------------------------------------
 
 const compileSig = f()
@@ -57,9 +53,57 @@ const compileSig = f()
   ))
   .build();
 
-const compileGen = ax(compileSig);
+interface ParsedCompileResult {
+  changeType: CompileResult["changeType"];
+  compiledTruth: string;
+  changeSummary: string;
+  confidence: number;
+}
+
+function parseCompileResult(raw: unknown): ParsedCompileResult | null {
+  const obj = parseJsonObject(raw);
+  if (!obj) return null;
+
+  const changeType = String(obj.changeType ?? "none");
+  const validTypes = ["append", "update", "replace", "none", "conflict"];
+  const normalizedType = validTypes.includes(changeType)
+    ? changeType as CompileResult["changeType"]
+    : "append";
+
+  const compiledTruth = String(obj.compiledTruth ?? "");
+  if (!compiledTruth) return null;
+
+  return {
+    changeType: normalizedType,
+    compiledTruth,
+    changeSummary: String(obj.changeSummary ?? ""),
+    confidence: typeof obj.confidence === "number" ? obj.confidence : 0.8,
+  };
+}
+
+const compilePipeline = new AIPipeline<CompileInput, ParsedCompileResult, {
+  parsed: ParsedCompileResult;
+  timelineEntries: TimelineEntry[];
+}>({
+  signature: compileSig,
+  mapInput: (input) => ({
+    currentTruth: input.currentTruth || "(empty)",
+    newInfo: input.newInfo,
+    infoSource: input.source,
+    infoDate: input.date,
+    context: buildContext(input),
+  }),
+  extractOutput: (raw) => raw.compilationResult,
+  parseRaw: parseCompileResult,
+  transform: (_parsed, _input) => ({ parsed: _parsed, timelineEntries: [] }),
+  fallback: fallbackAppend,
+  label: "Ax compilation",
+});
+
+// ---------------------------------------------------------------------------
+// Timeline extraction pipeline (used internally by compileTruth)
+// ---------------------------------------------------------------------------
 
-// Timeline extraction sub-signature
 const timelineSig = f()
   .input("newInfo", f.string("Information to extract timeline events from"))
   .input("infoSource", f.string("Source identifier"))
@@ -69,88 +113,83 @@ const timelineSig = f()
   ))
   .build();
 
-const timelineGen = ax(timelineSig);
+interface TimelineExtractInput {
+  newInfo: string;
+  infoSource: string;
+  infoDate: string;
+  pageSlug: string;
+}
 
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
+interface RawEvent { date?: string; summary?: string; detail?: string; }
 
-export async function compileTruth(
-  input: CompileInput,
-  llm: ResolvedLLM,
-): Promise<CompileResult> {
-  const aiClient = createAxAI(llm);
-  if (!aiClient) return fallbackAppend(input);
-
-  try {
-    // Step 1: Main compilation
-    const context = buildContext(input);
-    const result = await compileGen.forward(aiClient, {
-      currentTruth: input.currentTruth || "(empty)",
-      newInfo: input.newInfo,
-      infoSource: input.source,
-      infoDate: input.date,
-      context,
-    });
-
-    // Parse the JSON result
-    const compiled = parseCompileResult(result.compilationResult);
-    if (!compiled) return fallbackAppend(input);
-
-    // Step 2: Extract timeline entries
-    const timelineEntries = await extractTimeline(input, aiClient);
-
-    return {
-      compiledTruth: compiled.compiledTruth,
-      changed: compiled.changeType !== "none",
-      changeType: compiled.changeType,
-      changeSummary: compiled.changeSummary,
-      timelineEntries,
-      confidence: compiled.confidence,
-    };
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.warn(`[ebrain] Ax compilation failed, falling back to append: ${msg}`);
-    return fallbackAppend(input);
+function parseEvents(raw: unknown): RawEvent[] {
+  if (Array.isArray(raw)) return raw as RawEvent[];
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw) as RawEvent[]; } catch { return []; }
   }
+  return [];
 }
 
+const timelinePipeline = new AIPipeline<TimelineExtractInput, RawEvent[], TimelineEntry[]>({
+  signature: timelineSig,
+  mapInput: (input) => ({
+    newInfo: input.newInfo,
+    infoSource: input.infoSource,
+    infoDate: input.infoDate,
+  }),
+  extractOutput: (raw) => raw.events,
+  parseRaw: parseEvents,
+  transform: (rawEvents, input) => rawEvents.map(e => ({
+    pageSlug: input.pageSlug,
+    date: String(e.date ?? input.infoDate),
+    source: input.infoSource,
+    summary: String(e.summary ?? "").slice(0, 120),
+    detail: String(e.detail ?? ""),
+  })),
+  fallback: () => [],
+  label: "Ax timeline extraction",
+});
+
 // ---------------------------------------------------------------------------
-// Helpers
+// Public API (unchanged)
 // ---------------------------------------------------------------------------
 
-interface ParsedCompileResult {
-  changeType: CompileResult["changeType"];
-  compiledTruth: string;
-  changeSummary: string;
-  confidence: number;
-}
+export async function compileTruth(
+  input: CompileInput,
+  llm: ResolvedLLM,
+): Promise<CompileResult> {
+  // Step 1: Main compilation via AIPipeline
+  const result = await compilePipeline.run(input, llm);
 
-function parseCompileResult(raw: unknown): ParsedCompileResult | null {
-  let obj: Record<string, unknown>;
-  if (typeof raw === "string") {
-    try { obj = JSON.parse(raw); } catch { return null; }
-  } else if (typeof raw === "object" && raw !== null) {
-    obj = raw as Record<string, unknown>;
-  } else {
-    return null;
+  // If fallback was triggered, pipeline returns the full CompileResult
+  if ("compiledTruth" in result && !("parsed" in result)) {
+    return result as CompileResult;
   }
 
-  const changeType = String(obj.changeType ?? "none");
-  const validTypes = ["append", "update", "replace", "none", "conflict"];
-  const normalizedType = validTypes.includes(changeType) ? changeType as CompileResult["changeType"] : "append";
-
-  const compiledTruth = String(obj.compiledTruth ?? "");
-  if (!compiledTruth) return null;
+  // Step 2: Extract timeline entries via AIPipeline
+  const timelineInput: TimelineExtractInput = {
+    newInfo: input.newInfo,
+    infoSource: input.source,
+    infoDate: input.date,
+    pageSlug: input.pageContext?.slug ?? "",
+  };
+  const timelineEntries = await timelinePipeline.run(timelineInput, llm);
 
+  const compiled = result.parsed;
   return {
-    changeType: normalizedType,
-    compiledTruth,
-    changeSummary: String(obj.changeSummary ?? ""),
-    confidence: typeof obj.confidence === "number" ? obj.confidence : 0.8,
+    compiledTruth: compiled.compiledTruth,
+    changed: compiled.changeType !== "none",
+    changeType: compiled.changeType,
+    changeSummary: compiled.changeSummary,
+    timelineEntries,
+    confidence: compiled.confidence,
   };
 }
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
 function buildContext(input: CompileInput): string {
   const parts: string[] = [];
   if (input.pageContext) {
@@ -164,40 +203,6 @@ function buildContext(input: CompileInput): string {
   return parts.join("\n\n") || "(no additional context)";
 }
 
-async function extractTimeline(
-  input: CompileInput,
-  aiClient: ReturnType<typeof createAxAI>,
-): Promise<TimelineEntry[]> {
-  if (!aiClient) return [];
-  try {
-    const result = await timelineGen.forward(aiClient, {
-      newInfo: input.newInfo,
-      infoSource: input.source,
-      infoDate: input.date,
-    });
-
-    const rawEvents = parseEvents(result.events);
-    const pageSlug = input.pageContext?.slug ?? "";
-    return rawEvents.map(e => ({
-      pageSlug,
-      date: String(e.date ?? input.date),
-      source: input.source,
-      summary: String(e.summary ?? "").slice(0, 120),
-      detail: String(e.detail ?? ""),
-    }));
-  } catch {
-    return [];
-  }
-}
-
-interface RawEvent { date?: string; summary?: string; detail?: string; }
-
-function parseEvents(raw: unknown): RawEvent[] {
-  if (Array.isArray(raw)) return raw as RawEvent[];
-  if (typeof raw === "string") { try { return JSON.parse(raw) as RawEvent[]; } catch { return []; } }
-  return [];
-}
-
 function fallbackAppend(input: CompileInput): CompileResult {
   const timestamp = input.date || new Date().toISOString().slice(0, 10);
   const newLine = `- ${input.newInfo.trim()} (Source: ${input.source}, ${timestamp})`;

package/src/ai/entity-link.ts

@@ -1,14 +1,14 @@
 /**
- * Entity Link Extraction — Ax Signature version.
+ * Entity Link Extraction — AIPipeline version.
  *
- * Uses f.json() for complex output instead of f.object().array()
- * because Ax's tool calling response parsing has compatibility issues
- * with DashScope/qwen models.
+ * Uses AIPipeline for LLM call lifecycle (createAxAI → forward → parse → transform → fallback).
+ *
+ * Public API unchanged — drop-in replacement for callers.
  */
 
-import { ax, f } from "@ax-llm/ax";
+import { f } from "@ax-llm/ax";
 import type { ResolvedLLM } from "../settings";
-import { createAxAI } from "./ax-adapter";
+import { AIPipeline, normalizeFields } from "./ax-pipeline";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -38,7 +38,7 @@ export interface EntityRelation {
 export type ExtractionResult = EntityRelation[];
 
 // ---------------------------------------------------------------------------
-// Signature definition (using json type for complex output)
+// Entity pipeline configuration
 // ---------------------------------------------------------------------------
 
 const entitySig = f()
@@ -51,7 +51,61 @@ const entitySig = f()
   ))
   .build();
 
-const entityGen = ax(entitySig);
+interface RawRelation {
+  fromName?: string;
+  fromType?: string;
+  toName?: string;
+  toType?: string;
+  relation?: string;
+  context?: string;
+  confidence?: number;
+}
+
+function parseRelations(raw: unknown): RawRelation[] {
+  if (Array.isArray(raw)) {
+    return raw.map((item: Record<string, unknown>) => {
+      const normalized = normalizeFields(item, {
+        fromName: ['fromName', 'from_name', 'from', '来源'],
+        fromType: ['fromType', 'from_type', '来源类型'],
+        toName: ['toName', 'to_name', 'to', '目标'],
+        toType: ['toType', 'to_type', '目标类型'],
+        relation: ['relation', 'relationType', 'relation_type', '关系'],
+        context: ['context', 'description', '描述', '上下文'],
+      });
+      return {
+        fromName: String(normalized.fromName ?? ''),
+        fromType: String(normalized.fromType ?? ''),
+        toName: String(normalized.toName ?? ''),
+        toType: String(normalized.toType ?? ''),
+        relation: String(normalized.relation ?? ''),
+        context: String(normalized.context ?? ''),
+        confidence: typeof item.confidence === 'number' ? item.confidence :
+                    typeof item.confidence === 'string' ? parseFloat(item.confidence) || 0.8 : 0.8,
+      };
+    }).filter(r => r.fromName && r.toName && r.relation);
+  }
+  if (typeof raw === 'string') {
+    try {
+      const parsed = JSON.parse(raw) as Record<string, unknown>[];
+      return parseRelations(parsed);
+    } catch { return []; }
+  }
+  return [];
+}
+
+const entityPipeline = new AIPipeline<
+  { inputText: string },
+  RawRelation[],
+  RawRelation[]
+>({
+  signature: entitySig,
+  mapInput: (input) => input,
+  extractOutput: (raw) => raw.relations,
+  parseRaw: parseRelations,
+  transform: (raw) => raw,
+  fallback: () => [],
+  label: "Entity extraction",
+});
 
 // ---------------------------------------------------------------------------
 // Entity slug helpers
@@ -76,7 +130,39 @@ export function entityToSlug(name: string, type: EntityType): string {
 }
 
 // ---------------------------------------------------------------------------
-// Public API
+// Normalization helpers
+// ---------------------------------------------------------------------------
+
+function normalizeEntityType(raw: string): EntityType {
+  if (!raw) return "other";
+  const lower = raw.toLowerCase().trim();
+  if (lower.includes("person") || lower.includes("people") || lower.includes("人物") || lower.includes("人")) return "person";
+  if (lower.includes("company") || lower.includes("corp") || lower.includes("business") || lower.includes("公司") || lower.includes("企业")) return "company";
+  if (lower.includes("project") || lower.includes("项目") || lower.includes("产品")) return "project";
+  if (lower.includes("organization") || lower.includes("org") || lower.includes("ngo") || lower.includes("组织") || lower.includes("机构") || lower.includes("学校") || lower.includes("大学")) return "organization";
+  if (lower.includes("event") || lower.includes("事件") || lower.includes("活动")) return "event";
+  return "other";
+}
+
+function normalizeRelationType(raw: string): RelationType {
+  if (!raw) return "related_to";
+  const lower = raw.toLowerCase().trim().replace(/-/g, "_");
+  const validTypes: RelationType[] = ["founder_of", "works_at", "leader_of", "collaborates_with", "competes_with", "acquired", "part_of", "invested_in", "mentioned_in", "related_to"];
+  if (validTypes.includes(lower)) return lower;
+  if (lower.includes("founder") || lower.includes("create") || lower.includes("创办") || lower.includes("创立")) return "founder_of";
+  if (lower.includes("work") || lower.includes("join") || lower.includes("任职") || lower.includes("就职")) return "works_at";
+  if (lower.includes("lead") || lower.includes("head") || lower.includes("manage") || lower.includes("负责")) return "leader_of";
+  if (lower.includes("collabor") || lower.includes("partner") || lower.includes("合作")) return "collaborates_with";
+  if (lower.includes("compet") || lower.includes("竞争")) return "competes_with";
+  if (lower.includes("acquir") || lower.includes("buy") || lower.includes("收购")) return "acquired";
+  if (lower.includes("invest") || lower.includes("投资")) return "invested_in";
+  if (lower.includes("part") || lower.includes("belong") || lower.includes("隶属")) return "part_of";
+  if (lower.includes("mention") || lower.includes("refer") || lower.includes("提及")) return "mentioned_in";
+  return "related_to";
+}
+
+// ---------------------------------------------------------------------------
+// Public API (unchanged)
 // ---------------------------------------------------------------------------
 
 export async function extractRelations(
@@ -89,17 +175,13 @@ export async function extractRelations(
   const trimmed = content.trim();
   if (!trimmed) return [];
 
-  const aiClient = createAxAI(llm);
-  if (!aiClient) return [];
-
   const context = trimmed.length <= 5000
     ? trimmed
     : trimmed.slice(0, 4000) + "\n\n...\n\n" + trimmed.slice(-1000);
 
   try {
-    const result = await entityGen.forward(aiClient, { inputText: context });
+    const rawRelations = await entityPipeline.run({ inputText: context }, llm);
 
-    const rawRelations = parseRelations(result.relations);
     const threshold = options?.confidenceThreshold ?? 0.7;
 
     const relations: ExtractionResult = [];
@@ -122,67 +204,3 @@ export async function extractRelations(
     return [];
   }
 }
-
-interface RawRelation {
-  fromName?: string;
-  fromType?: string;
-  toName?: string;
-  toType?: string;
-  relation?: string;
-  context?: string;
-  confidence?: number;
-}
-
-function parseRelations(raw: unknown): RawRelation[] {
-  if (Array.isArray(raw)) {
-    // Handle both English and Chinese field names from LLM output
-    return raw.map((item: Record<string, unknown>) => {
-      // Normalize field names: accept both English and Chinese variants
-      return {
-        fromName: String(item.fromName ?? item.from_name ?? item.from ?? item.来源 ?? ''),
-        fromType: String(item.fromType ?? item.from_type ?? item.fromType ?? item.来源类型 ?? ''),
-        toName: String(item.toName ?? item.to_name ?? item.to ?? item.目标 ?? ''),
-        toType: String(item.toType ?? item.to_type ?? item.toType ?? item.目标类型 ?? ''),
-        relation: String(item.relation ?? item.relationType ?? item.relation_type ?? item.关系 ?? ''),
-        context: String(item.context ?? item.description ?? item.描述 ?? item.上下文 ?? ''),
-        confidence: typeof item.confidence === 'number' ? item.confidence : 
-                    typeof item.confidence === 'string' ? parseFloat(item.confidence) || 0.8 : 0.8,
-      };
-    }).filter(r => r.fromName && r.toName && r.relation);
-  }
-  if (typeof raw === 'string') {
-    try {
-      const parsed = JSON.parse(raw) as Record<string, unknown>[];
-      return parseRelations(parsed);
-    } catch { return []; }
-  }
-  return [];
-}
-
-function normalizeEntityType(raw: string): EntityType {
-  if (!raw) return "other";
-  const lower = raw.toLowerCase().trim();
-  if (lower.includes("person") || lower.includes("people") || lower.includes("人物") || lower.includes("人")) return "person";
-  if (lower.includes("company") || lower.includes("corp") || lower.includes("business") || lower.includes("公司") || lower.includes("企业")) return "company";
-  if (lower.includes("project") || lower.includes("项目") || lower.includes("产品")) return "project";
-  if (lower.includes("organization") || lower.includes("org") || lower.includes("ngo") || lower.includes("组织") || lower.includes("机构") || lower.includes("学校") || lower.includes("大学")) return "organization";
-  if (lower.includes("event") || lower.includes("事件") || lower.includes("活动")) return "event";
-  return "other";
-}
-
-export function normalizeRelationType(raw: string): RelationType {
-  if (!raw) return "related_to";
-  const lower = raw.toLowerCase().trim().replace(/-/g, "_");
-  const validTypes = ["founder_of", "works_at", "leader_of", "collaborates_with", "competes_with", "acquired", "part_of", "invested_in", "mentioned_in", "related_to"];
-  if (validTypes.includes(lower)) return lower as RelationType;
-  if (lower.includes("founder") || lower.includes("create") || lower.includes("创办") || lower.includes("创立")) return "founder_of";
-  if (lower.includes("work") || lower.includes("join") || lower.includes("任职") || lower.includes("就职")) return "works_at";
-  if (lower.includes("lead") || lower.includes("head") || lower.includes("manage") || lower.includes("负责")) return "leader_of";
-  if (lower.includes("collabor") || lower.includes("partner") || lower.includes("合作")) return "collaborates_with";
-  if (lower.includes("compet") || lower.includes("竞争")) return "competes_with";
-  if (lower.includes("acquir") || lower.includes("buy") || lower.includes("收购")) return "acquired";
-  if (lower.includes("invest") || lower.includes("投资")) return "invested_in";
-  if (lower.includes("part") || lower.includes("belong") || lower.includes("隶属")) return "part_of";
-  if (lower.includes("mention") || lower.includes("refer") || lower.includes("提及")) return "mentioned_in";
-  return "related_to";
-}