@astro-minimax/ai 0.8.3 → 0.9.0

package/dist/cache/global-cache.js

@@ -0,0 +1,145 @@
+const PUBLIC_QUESTION_PATTERNS = [
+  {
+    type: "tech",
+    keywords: ["\u6280\u672F\u6808", "\u6280\u672F", "\u6846\u67B6", "\u7528\u4E86\u4EC0\u4E48", "built with", "tech stack", "framework"],
+    patterns: [
+      /这个博客用了什么/,
+      /博客.*技术栈/,
+      /用了什么技术/,
+      /what.*tech.*stack/,
+      /built with/,
+      /用什么框架/
+    ],
+    ttl: 86400,
+    needsContext: false
+  },
+  {
+    type: "recommend",
+    keywords: ["\u63A8\u8350", "\u6587\u7AE0\u63A8\u8350", "\u597D\u6587", "recommend", "suggest"],
+    patterns: [
+      /推荐.*文章/,
+      /有哪些推荐/,
+      /文章推荐/,
+      /recommend.*article/,
+      /any.*recommend/
+    ],
+    ttl: 1800,
+    needsContext: false
+  },
+  {
+    type: "build",
+    keywords: ["\u642D\u5EFA", "\u90E8\u7F72", "\u600E\u4E48\u5EFA", "how to build", "deploy", "setup"],
+    patterns: [
+      /怎么搭建/,
+      /如何搭建/,
+      /怎么部署/,
+      /how to build/,
+      /how to deploy/,
+      /搭建.*博客/
+    ],
+    ttl: 86400,
+    needsContext: false
+  },
+  {
+    type: "summary",
+    keywords: ["\u603B\u7ED3", "\u6982\u62EC", "\u6458\u8981", "summarize", "summary", "tl;dr"],
+    patterns: [
+      /总结(一下|这篇文章)/,
+      /概括(一下|这篇文章)/,
+      /文章摘要/,
+      /summarize/,
+      /summary/,
+      /主要讲了什么/
+    ],
+    ttl: 14400,
+    needsContext: true
+  },
+  {
+    type: "author",
+    keywords: ["\u4F5C\u8005", "\u535A\u4E3B", "\u8C01", "author", "who"],
+    patterns: [
+      /作者是谁/,
+      /博主是谁/,
+      /关于作者/,
+      /who.*author/,
+      /about author/
+    ],
+    ttl: 86400,
+    needsContext: false
+  },
+  {
+    type: "about",
+    keywords: ["\u5173\u4E8E", "\u4ECB\u7ECD", "about", "intro"],
+    patterns: [
+      /关于.*博客/,
+      /博客介绍/,
+      /about.*blog/,
+      /介绍一下/
+    ],
+    ttl: 86400,
+    needsContext: false
+  }
+];
+function detectPublicQuestion(query) {
+  const normalized = normalizeQuery(query);
+  let bestMatch = null;
+  let bestScore = 0;
+  for (const pattern of PUBLIC_QUESTION_PATTERNS) {
+    let score = 0;
+    for (const keyword of pattern.keywords) {
+      if (normalized.includes(keyword.toLowerCase())) {
+        score += 1;
+      }
+    }
+    for (const regex of pattern.patterns) {
+      if (regex.test(normalized)) {
+        score += 3;
+      }
+    }
+    if (score > bestScore && score >= 2) {
+      bestScore = score;
+      const confidence = Math.min(score / 5, 1);
+      bestMatch = {
+        type: pattern.type,
+        confidence,
+        ttl: pattern.ttl,
+        needsContext: pattern.needsContext
+      };
+    }
+  }
+  return bestMatch;
+}
+function buildGlobalCacheKey(type, context) {
+  const parts = ["global", type];
+  if (context?.articleSlug) {
+    parts.push(context.articleSlug);
+  }
+  if (context?.lang) {
+    parts.push(context.lang);
+  }
+  return parts.join(":");
+}
+function normalizeQuery(query) {
+  return query.toLowerCase().replace(/[？?!！。，,.]/g, "").replace(/\s+/g, " ").trim();
+}
+async function getGlobalSearchCache(cache, type, context) {
+  const key = buildGlobalCacheKey(type, context);
+  const entry = await cache.get(key);
+  return entry?.value ?? null;
+}
+async function setGlobalSearchCache(cache, type, data, ttl, context) {
+  const key = buildGlobalCacheKey(type, context);
+  await cache.set(key, data, { ttl });
+}
+function getGlobalCacheTTL(type) {
+  const pattern = PUBLIC_QUESTION_PATTERNS.find((p) => p.type === type);
+  return pattern?.ttl ?? 3600;
+}
+export {
+  PUBLIC_QUESTION_PATTERNS,
+  buildGlobalCacheKey,
+  detectPublicQuestion,
+  getGlobalCacheTTL,
+  getGlobalSearchCache,
+  setGlobalSearchCache
+};

package/dist/cache/index.js

@@ -0,0 +1,96 @@
+import {
+  MemoryCacheAdapter
+} from "./memory-adapter.js";
+import {
+  KVCacheAdapter
+} from "./kv-adapter.js";
+import {
+  createCacheKeyBuilder
+} from "./types.js";
+import {
+  detectPublicQuestion,
+  buildGlobalCacheKey,
+  getGlobalSearchCache,
+  setGlobalSearchCache,
+  getGlobalCacheTTL,
+  PUBLIC_QUESTION_PATTERNS
+} from "./global-cache.js";
+import {
+  getResponseCache,
+  setResponseCache,
+  deleteResponseCache,
+  getResponseCacheConfig,
+  buildResponseCacheKey,
+  createResponsePlaybackGenerator,
+  DEFAULT_RESPONSE_CACHE_CONFIG
+} from "./response-cache.js";
+import { MemoryCacheAdapter as MemoryCacheAdapter2 } from "./memory-adapter.js";
+import { KVCacheAdapter as KVCacheAdapter2 } from "./kv-adapter.js";
+const DEFAULT_TTL = 600;
+const DEFAULT_MAX_ENTRIES = 400;
+let globalMemoryCache = null;
+function getGlobalMemoryCache(ttl, maxEntries) {
+  if (!globalMemoryCache) {
+    globalMemoryCache = new MemoryCacheAdapter2({ defaultTtl: ttl, maxEntries });
+  }
+  return globalMemoryCache;
+}
+function createCacheAdapter(env, config) {
+  const ttl = config?.defaultTtl ?? parseTtl(env.CACHE_TTL) ?? DEFAULT_TTL;
+  const maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  if (isCacheDisabled(env)) {
+    return getGlobalMemoryCache(ttl, maxEntries);
+  }
+  const kvBinding = getKVBinding(env);
+  if (kvBinding) {
+    return new KVCacheAdapter2(kvBinding, { defaultTtl: ttl });
+  }
+  return getGlobalMemoryCache(ttl, maxEntries);
+}
+function isCacheDisabled(env) {
+  const val = env.CACHE_DISABLED;
+  if (val === true || val === "true" || val === "1") {
+    return true;
+  }
+  return false;
+}
+function getKVBinding(env) {
+  const customBinding = env.CACHE_KV_BINDING;
+  if (customBinding && typeof customBinding === "string") {
+    const binding = env[customBinding];
+    return isKVNamespace(binding) ? binding : null;
+  }
+  if (env.CACHE_KV && isKVNamespace(env.CACHE_KV)) {
+    return env.CACHE_KV;
+  }
+  const defaultBinding = env["CACHE_KV"];
+  return isKVNamespace(defaultBinding) ? defaultBinding : null;
+}
+function isKVNamespace(value) {
+  return typeof value === "object" && value !== null && "get" in value && "put" in value && "delete" in value;
+}
+function parseTtl(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number") return value;
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? void 0 : parsed;
+}
+export {
+  DEFAULT_RESPONSE_CACHE_CONFIG,
+  KVCacheAdapter,
+  MemoryCacheAdapter,
+  PUBLIC_QUESTION_PATTERNS,
+  buildGlobalCacheKey,
+  buildResponseCacheKey,
+  createCacheAdapter,
+  createCacheKeyBuilder,
+  createResponsePlaybackGenerator,
+  deleteResponseCache,
+  detectPublicQuestion,
+  getGlobalCacheTTL,
+  getGlobalSearchCache,
+  getResponseCache,
+  getResponseCacheConfig,
+  setGlobalSearchCache,
+  setResponseCache
+};

package/dist/cache/kv-adapter.js

@@ -0,0 +1,99 @@
+const DEFAULT_TTL_SECONDS = 600;
+const MIN_TTL_SECONDS = 60;
+class KVCacheAdapter {
+  name = "cloudflare-kv";
+  kv;
+  defaultTtl;
+  prefix;
+  constructor(kv, options) {
+    this.kv = kv;
+    this.defaultTtl = options?.defaultTtl ?? DEFAULT_TTL_SECONDS;
+    this.prefix = options?.prefix ?? "";
+  }
+  buildKey(key) {
+    return this.prefix ? `${this.prefix}:${key}` : key;
+  }
+  async get(key, options) {
+    try {
+      const fullKey = this.buildKey(key);
+      const result = await this.kv.getWithMetadata(fullKey, "json");
+      if (!result.value) {
+        return null;
+      }
+      const storedEntry = result.value;
+      if (!storedEntry.value || !storedEntry.metadata) {
+        return null;
+      }
+      return {
+        value: storedEntry.value,
+        metadata: storedEntry.metadata
+      };
+    } catch (error) {
+      if (!options?.silent) {
+        console.error("[KVCacheAdapter] Get error:", error);
+      }
+      return null;
+    }
+  }
+  async set(key, value, options) {
+    try {
+      const now = Date.now();
+      const ttl = options?.ttl ?? this.defaultTtl;
+      const entry = {
+        value,
+        metadata: {
+          createdAt: now,
+          updatedAt: now,
+          custom: options?.metadata
+        }
+      };
+      const fullKey = this.buildKey(key);
+      const effectiveTtl = Math.max(ttl, MIN_TTL_SECONDS);
+      await this.kv.put(fullKey, JSON.stringify(entry), {
+        expirationTtl: effectiveTtl
+      });
+    } catch (error) {
+      console.error("[KVCacheAdapter] Set error:", error);
+      throw error;
+    }
+  }
+  async delete(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const existing = await this.kv.get(fullKey);
+      if (existing === null) {
+        return false;
+      }
+      await this.kv.delete(fullKey);
+      return true;
+    } catch (error) {
+      console.error("[KVCacheAdapter] Delete error:", error);
+      return false;
+    }
+  }
+  async clear() {
+    console.warn("[KVCacheAdapter] Clear not supported for KV namespace");
+  }
+  async has(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const value = await this.kv.get(fullKey);
+      return value !== null;
+    } catch {
+      return false;
+    }
+  }
+  async isAvailable() {
+    try {
+      await this.kv.get("__health_check__");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  dispose() {
+  }
+}
+export {
+  KVCacheAdapter
+};

package/dist/cache/memory-adapter.js

@@ -0,0 +1,97 @@
+const DEFAULT_MAX_ENTRIES = 400;
+const DEFAULT_TTL_SECONDS = 600;
+class MemoryCacheAdapter {
+  name = "memory";
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  defaultTtl;
+  cleanupTimer;
+  constructor(options) {
+    this.maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.defaultTtl = options?.defaultTtl ?? DEFAULT_TTL_SECONDS;
+    if (options?.cleanupInterval) {
+      this.cleanupTimer = setInterval(
+        () => this.cleanup(),
+        options.cleanupInterval * 1e3
+      );
+    }
+  }
+  async get(key, _options) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return {
+      value: entry.value,
+      metadata: entry.metadata
+    };
+  }
+  async set(key, value, options) {
+    const now = Date.now();
+    const ttl = options?.ttl ?? this.defaultTtl;
+    const entry = {
+      value,
+      metadata: {
+        createdAt: now,
+        updatedAt: now,
+        custom: options?.metadata
+      },
+      expiresAt: ttl ? now + ttl * 1e3 : void 0
+    };
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    if (this.cache.size > this.maxEntries) {
+      this.evictLRU();
+    }
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async isAvailable() {
+    return true;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (entry.expiresAt && now > entry.expiresAt) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  evictLRU() {
+    const overflow = this.cache.size - this.maxEntries;
+    if (overflow <= 0) return;
+    const keys = this.cache.keys();
+    for (let i = 0; i < overflow; i++) {
+      const next = keys.next();
+      if (next.done) break;
+      this.cache.delete(next.value);
+    }
+  }
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    this.cache.clear();
+  }
+}
+export {
+  MemoryCacheAdapter
+};

package/dist/cache/response-cache.js

@@ -0,0 +1,87 @@
+const DEFAULT_RESPONSE_CACHE_CONFIG = {
+  enabled: false,
+  defaultTtl: 3600,
+  playbackDelayMs: 20,
+  chunkSize: 15,
+  thinkingPlaybackDelayMs: 5
+};
+function getResponseCacheConfig(env) {
+  const parseBool = (val) => {
+    if (val === void 0) return false;
+    if (typeof val === "boolean") return val;
+    if (typeof val === "string") return val === "true" || val === "1";
+    return false;
+  };
+  const parseNum = (val, defaultVal) => {
+    if (val === void 0) return defaultVal;
+    if (typeof val === "number") return val;
+    if (typeof val === "string") {
+      const num = parseInt(val, 10);
+      return isNaN(num) ? defaultVal : num;
+    }
+    return defaultVal;
+  };
+  return {
+    enabled: parseBool(env.AI_RESPONSE_CACHE_ENABLED),
+    defaultTtl: parseNum(env.AI_RESPONSE_CACHE_TTL, 3600),
+    playbackDelayMs: parseNum(env.AI_RESPONSE_CACHE_PLAYBACK_DELAY, 20),
+    chunkSize: parseNum(env.AI_RESPONSE_CACHE_CHUNK_SIZE, 15),
+    thinkingPlaybackDelayMs: parseNum(env.AI_RESPONSE_CACHE_THINKING_DELAY, 5)
+  };
+}
+const RESPONSE_CACHE_PREFIX = "response";
+function buildResponseCacheKey(type, context) {
+  const parts = [RESPONSE_CACHE_PREFIX, type];
+  if (context?.articleSlug) parts.push(context.articleSlug);
+  if (context?.lang) parts.push(context.lang);
+  return parts.join(":");
+}
+async function getResponseCache(cache, type, context) {
+  const key = buildResponseCacheKey(type, context);
+  const entry = await cache.get(key);
+  return entry?.value ?? null;
+}
+async function setResponseCache(cache, type, data, ttl, context) {
+  const key = buildResponseCacheKey(type, context);
+  await cache.set(key, data, { ttl });
+}
+async function deleteResponseCache(cache, type, context) {
+  const key = buildResponseCacheKey(type, context);
+  return cache.delete(key);
+}
+function createResponsePlaybackGenerator(cached, config) {
+  const { playbackDelayMs, chunkSize, thinkingPlaybackDelayMs } = config;
+  return (async function* () {
+    if (cached.thinking) {
+      const thinkingChunks = Math.ceil(cached.thinking.length / chunkSize);
+      for (let i = 0; i < thinkingChunks; i++) {
+        const chunk = cached.thinking.slice(i * chunkSize, (i + 1) * chunkSize);
+        if (chunk) {
+          yield { type: "thinking", text: chunk };
+          if (i < thinkingChunks - 1 && thinkingPlaybackDelayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, thinkingPlaybackDelayMs));
+          }
+        }
+      }
+    }
+    const responseChunks = Math.ceil(cached.response.length / chunkSize);
+    for (let i = 0; i < responseChunks; i++) {
+      const chunk = cached.response.slice(i * chunkSize, (i + 1) * chunkSize);
+      if (chunk) {
+        yield { type: "response", text: chunk };
+        if (i < responseChunks - 1 && playbackDelayMs > 0) {
+          await new Promise((resolve) => setTimeout(resolve, playbackDelayMs));
+        }
+      }
+    }
+  })();
+}
+export {
+  DEFAULT_RESPONSE_CACHE_CONFIG,
+  buildResponseCacheKey,
+  createResponsePlaybackGenerator,
+  deleteResponseCache,
+  getResponseCache,
+  getResponseCacheConfig,
+  setResponseCache
+};

package/dist/cache/types.js

@@ -0,0 +1,8 @@
+const createCacheKeyBuilder = (prefix = "chat") => ({
+  session: (sessionId) => `${prefix}:sid:${sessionId}`,
+  article: (sessionId, slug) => `${prefix}:sid:${sessionId}:article:${slug}`,
+  custom: (...parts) => `${prefix}:${parts.join(":")}`
+});
+export {
+  createCacheKeyBuilder
+};

package/dist/data/metadata-loader.js

@@ -0,0 +1,48 @@
+import { loadFactRegistry as loadFactRegistryCache } from "../fact-registry/registry.js";
+import { loadVectorIndex as loadVectorIndexCache } from "../search/vector-reranker.js";
+let cachedMetadata = null;
+function preloadMetadata(data) {
+  cachedMetadata = {
+    summaries: data.summaries ?? null,
+    authorContext: data.authorContext ?? null,
+    voiceProfile: data.voiceProfile ?? null,
+    factRegistry: data.factRegistry ?? null,
+    vectorIndex: data.vectorIndex ?? null
+  };
+  if (cachedMetadata.factRegistry) {
+    loadFactRegistryCache(cachedMetadata.factRegistry);
+  }
+  if (cachedMetadata.vectorIndex) {
+    loadVectorIndexCache(cachedMetadata.vectorIndex);
+  }
+}
+function clearMetadataCache() {
+  cachedMetadata = null;
+  loadFactRegistryCache(null);
+  loadVectorIndexCache(null);
+}
+function getMetadata() {
+  return cachedMetadata ?? { summaries: null, authorContext: null, voiceProfile: null, factRegistry: null, vectorIndex: null };
+}
+function getArticleSummary(slug) {
+  return cachedMetadata?.summaries?.articles[slug]?.data;
+}
+function getAllSummaries() {
+  const articles = cachedMetadata?.summaries?.articles ?? {};
+  return Object.entries(articles).map(([slug, entry]) => ({ slug, ...entry.data }));
+}
+function getAuthorContext() {
+  return cachedMetadata?.authorContext ?? null;
+}
+function getVoiceProfile() {
+  return cachedMetadata?.voiceProfile ?? null;
+}
+export {
+  clearMetadataCache,
+  getAllSummaries,
+  getArticleSummary,
+  getAuthorContext,
+  getMetadata,
+  getVoiceProfile,
+  preloadMetadata
+};

package/dist/fact-registry/fact-matcher.js

@@ -0,0 +1,128 @@
+import { queryFacts } from "./registry.js";
+const CATEGORY_KEYWORDS = {
+  author: [
+    "\u4F5C\u8005",
+    "\u535A\u4E3B",
+    "\u8C01",
+    "\u5173\u4E8E\u6211",
+    "\u81EA\u6211\u4ECB\u7ECD",
+    "\u4E2A\u4EBA",
+    "author",
+    "who",
+    "about me",
+    "introduce"
+  ],
+  blog: [
+    "\u535A\u5BA2",
+    "\u6587\u7AE0",
+    "\u591A\u5C11",
+    "\u6570\u91CF",
+    "\u7EDF\u8BA1",
+    "\u603B\u5171",
+    "\u5206\u7C7B",
+    "\u6807\u7B7E",
+    "\u8BED\u8A00",
+    "blog",
+    "post",
+    "how many",
+    "count",
+    "statistic",
+    "category",
+    "tag"
+  ],
+  content: [
+    "\u5199\u8FC7",
+    "\u63D0\u5230",
+    "\u8BA8\u8BBA",
+    "\u89C2\u70B9",
+    "\u4E3B\u9898",
+    "\u8BDD\u9898",
+    "\u6DB5\u76D6",
+    "\u9886\u57DF",
+    "wrote",
+    "mention",
+    "discuss",
+    "topic",
+    "cover",
+    "area",
+    "opinion"
+  ],
+  project: [
+    "\u9879\u76EE",
+    "\u5F00\u6E90",
+    "\u4ED3\u5E93",
+    "\u5DE5\u5177",
+    "\u4EA7\u54C1",
+    "project",
+    "open source",
+    "repo",
+    "github",
+    "tool",
+    "product"
+  ],
+  tech: [
+    "\u6280\u672F",
+    "\u6280\u672F\u6808",
+    "\u6846\u67B6",
+    "\u5E93",
+    "\u7F16\u7A0B\u8BED\u8A00",
+    "\u524D\u7AEF",
+    "\u540E\u7AEF",
+    "tech",
+    "stack",
+    "framework",
+    "library",
+    "language",
+    "frontend",
+    "backend"
+  ]
+};
+function detectRelevantCategories(query) {
+  const q = query.toLowerCase();
+  const matched = [];
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    if (keywords.some((kw) => q.includes(kw))) {
+      matched.push(category);
+    }
+  }
+  return matched;
+}
+function extractQueryTags(query) {
+  const tokens = query.match(
+    /[A-Za-z][A-Za-z0-9.+#-]{1,}|[\u4e00-\u9fa5]{2,6}/g
+  );
+  return tokens?.map((t) => t.toLowerCase()) ?? [];
+}
+function matchFactsToQuery(query, lang, maxFacts = 15) {
+  const categories = detectRelevantCategories(query);
+  const queryTags = extractQueryTags(query);
+  const coreFacts = queryFacts({
+    minConfidence: 0.95,
+    lang,
+    limit: 5
+  });
+  const categoryFacts = categories.length > 0 ? queryFacts({
+    categories,
+    minConfidence: 0.7,
+    lang,
+    limit: 10
+  }) : [];
+  const tagFacts = queryTags.length > 0 ? queryFacts({
+    tags: queryTags,
+    minConfidence: 0.6,
+    lang,
+    limit: 5
+  }) : [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const fact of [...categoryFacts, ...tagFacts, ...coreFacts]) {
+    if (!seen.has(fact.id)) {
+      seen.add(fact.id);
+      result.push(fact);
+    }
+  }
+  return result.slice(0, maxFacts);
+}
+export {
+  matchFactsToQuery
+};